Čo je to mutex?

Mutex (mutex, Mutual Exclusion) je mechanizmus synchronizácie, ktorý sa používa na ochranu spoločného zdroja pred súčasným prístupom z viacerých vlákien (alebo procesov). V každom momente môže vlastniť mutex iba jedno vlákno a zodpovedajúcim spôsobom získať prístup k chránenému zdroju.

Hlavné operácie s mutexom:

• lock (zámok): Pokus získať vlastníctvo mutexu. Ak je mutex voľný, vlákno ho získa a pokračuje v vykonávaní. Ak je mutex už obsadený iným vláknom, aktuálne vlákno sa zablokuje, kým nebude mutex uvoľnený.
• unlock (uvoľnenie): Uvoľnenie vlastníctva mutexu. To umožňuje inému čakajúcemu vláknu ho získať. Je dôležité, aby mutex uvoľnilo to isté vlákno, ktoré ho získalo.

Napríklad v Objective-C alebo Swift na prácu s mutexmi môžete použiť NSLock.

Príklad použitia 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]; // Zámok mutexu
    @try {
        // Práca so _sharedResource - kritická sekcia
        _sharedResource++;
        NSLog(@"Shared resource updated to %d by thread %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Uvoľnenie mutexu
    }
}

@end

Príklad použitia NSLock v Swift:

//  Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Zámok mutexu
        // Práca so sharedResource - kritická sekcia
        sharedResource += 1
        print("Shared resource updated to \(sharedResource) by thread \(Thread.current)")
        lock.unlock() // Uvoľnenie mutexu
    }
}

Mutexy zabraňujú stavu súťaže (race condition) a zabezpečujú integritu dát pri paralelnom prístupe. Nesprávne použitie mutexov môže viesť k vzájomným zámkom (deadlocks).