Co je to mutex?

Mutex (Mutual Exclusion) je mechanismus synchronizace, který se používá k ochraně sdíleného zdroje před současným přístupem více vláken (nebo procesů). V každém okamžiku může vlastnit mutex pouze jedno vlákno a tím získat přístup k chráněnému zdroji.

Hlavní operace s mutexem:

• lock (zamknutí): Pokus o získání vlastnictví mutexu. Pokud je mutex volný, vlákno ho získá a pokračuje v provádění. Pokud je již obsazen jiným vláknem, aktuální vlákno je zablokováno, dokud není mutex uvolněn.
• unlock (odemknutí): Uvolnění vlastnictví mutexu. To umožní jinému čekajícímu vláknu, aby ho získalo. Je důležité, aby mutex uvolnilo stejné vlákno, které ho získalo.

Například v Objective-C nebo Swift lze použít NSLock pro práci s mutexy.

Příklad použití NSLock v 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]; // Zamknutí mutexu
    @try {
        // Práce se _sharedResource - kritická sekce
        _sharedResource++;
        NSLog(@"Sdílený zdroj aktualizován na %d vlákem %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Odemknutí mutexu
    }
}

@end

Příklad použití NSLock ve Swift:

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Zamknutí mutexu
        // Práce se sharedResource - kritická sekce
        sharedResource += 1
        print("Sdílený zdroj aktualizován na \(sharedResource) vlákem \(Thread.current)")
        lock.unlock() // Odemknutí mutexu
    }
}

Mutexy zabraňují závodním podmínkám (race condition) a zajišťují integritu dat při paralelním přístupu. Nesprávné použití může vést k deadlockům.