Mi az a mutex?

A mutex (Mutual Exclusion) egy szinkronizációs mechanizmus, amelyet arra használnak, hogy megvédjék a közös erőforrást a több szál (vagy folyamat) egyidejű hozzáférésétől. Minden pillanatban csak egy szál lehet a mutex tulajdonosa, és így hozzáférhet a védett erőforráshoz.

A mutex fő műveletei:

• lock (zár): A mutex megszerzésének kísérlete. Ha a mutex szabad, a szál megszerzi és folytatja a végrehajtást. Ha már más szál fogja, a jelenlegi szál blokkolva lesz, amíg a mutex fel nem szabadul.
• unlock (feloldás): A mutex felszabadítása. Ez lehetővé teszi egy másik várakozó szálnak, hogy megszerezze. Fontos, hogy a mutexet ugyanaz a szál oldja fel, amelyik megszerezte.

Például Objective-C vagy Swift esetén az NSLock használható mutexek kezelésére.

Példa az NSLock használatára Objective-C-ben:

// 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]; // Mutex zárolása
    @try {
        // Munka a _sharedResource-vel - kritikus szekció
        _sharedResource++;
        NSLog(@"Megosztott erőforrás frissítve: %d által a szál %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Mutex feloldása
    }
}

@end

Swift-ben az NSLock használata:

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Mutex zárolása
        // Munka a sharedResource-vel - kritikus szekció
        sharedResource += 1
        print("Megosztott erőforrás frissítve: \(sharedResource) által a szál \(Thread.current)")
        lock.unlock() // Mutex feloldása
    }
}

A mutexek megakadályozzák a versenyhelyzeteket (race condition) és biztosítják az adatok integritását párhuzamos hozzáférés esetén. A helytelen használat deadlock-okat eredményezhet.