Czym jest mutex?

Mutex (Mutual Exclusion) to mechanizm synchronizacji, który służy do ochrony wspólnego zasobu przed jednoczesnym dostępem z wielu wątków (lub procesów). W każdym momencie tylko jeden wątek może posiadać mutex i uzyskać dostęp do chronionego zasobu.

Podstawowe operacje na mutexie:

• lock (blokada): Próba uzyskania własności mutexa. Jeśli mutex jest wolny, wątek go przejmuje i kontynuuje wykonywanie. Jeśli mutex jest już zajęty przez inny wątek, bieżący wątek zostaje zablokowany do czasu zwolnienia mutexa.
• unlock (odblokowanie): Zwolnienie własności mutexa. Pozwala to innemu oczekującemu wątkowi przejąć mutex. Ważne jest, aby mutex był zwalniany przez ten sam wątek, który go przejął.

Na przykład w Objective-C lub Swift można używać NSLock do pracy z mutexami.

Przykład użycia NSLock w Objective-C:

// Objective-C
#import <Foundation/Foundation.h>

@interface MyClass : NSObject {
    NSLock *_lock;
    int _sharedResource;
}
@end

@implementation MyClass

- (instancetype)init {
    self = [super init];
    if (self) {
        _lock = [[NSLock alloc] init];
        _sharedResource = 0;
    }
    return self;
}

- (void)updateSharedResource {
    [_lock lock]; // Zabezpieczenie mutex
    @try {
        // Praca z _sharedResource - sekcja krytyczna
        _sharedResource++;
        NSLog(@"Zaktualizowano zasób współdzielony do %d przez wątek %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Zwolnienie mutexa
    }
}

@end

Przykład użycia NSLock w Swift:

// Swift
import Foundation

class MyClass {
    private let lock = NSLock()
    private var sharedResource = 0

    func updateSharedResource() {
        lock.lock() // Zabezpieczenie mutex
        // Praca z sharedResource - sekcja krytyczna
        sharedResource += 1
        print("Zaktualizowano zasób współdzielony do \(sharedResource) przez wątek \(Thread.current)")
        lock.unlock() // Zwolnienie mutexa
    }
}

Mutexy zapobiegają warunkom wyścigu (race condition) i zapewniają integralność danych podczas równoległego dostępu. Nieprawidłowe użycie mutexów może prowadzić do deadlocków.