Was ist ein Mutex?

Mutex (Mutual Exclusion) ist ein Synchronisationsmechanismus, der verwendet wird, um eine gemeinsame Ressource vor gleichzeitigen Zugriffen mehrerer Threads (oder Prozesse) zu schützen. Zu jedem Zeitpunkt kann nur ein Thread den Mutex besitzen und auf die geschützte Ressource zugreifen.

Hauptoperationen mit Mutex:

• lock (Sperre): Versuch, den Mutex zu erwerben. Wenn der Mutex frei ist, übernimmt der Thread ihn und setzt die Ausführung fort. Wenn der Mutex bereits von einem anderen Thread gehalten wird, wird der aktuelle Thread blockiert, bis der Mutex freigegeben wird.
• unlock (Freigabe): Freigabe des Mutex. Dies ermöglicht einem anderen wartenden Thread, ihn zu übernehmen. Es ist wichtig, dass der Mutex vom selben Thread freigegeben wird, der ihn gehalten hat.

Zum Beispiel kann man in Objective-C oder Swift NSLock verwenden, um mit Mutexen zu arbeiten.

Beispiel für die Verwendung von NSLock in 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]; // Mutex sperren
    @try {
        // Arbeiten mit _sharedResource - kritischer Abschnitt
        _sharedResource++;
        NSLog(@"Gemeinsame Ressource aktualisiert auf %d durch Thread %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Mutex freigeben
    }
}

@end

Beispiel für die Verwendung von NSLock in Swift:

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Mutex sperren
        // Arbeiten mit sharedResource - kritischer Abschnitt
        sharedResource += 1
        print("Gemeinsame Ressource aktualisiert auf \(sharedResource) durch Thread \(Thread.current)")
        lock.unlock() // Mutex freigeben
    }
}

Mutexes verhindern Race Conditions und gewährleisten die Datenintegrität bei parallelem Zugriff. Falsche Verwendung kann zu Deadlocks führen.