Qu'est-ce qu'un mutex?

Un mutex (exclusion mutuelle) est un mécanisme de synchronisation utilisé pour protéger une ressource partagée contre un accès simultané par plusieurs threads (ou processus). À tout moment, un seul thread peut posséder le mutex et accéder à la ressource protégée.

Les opérations principales sur un mutex :

• lock (verrouillage) : Tentative d'acquérir la possession du mutex. Si le mutex est libre, le thread le prend et continue l'exécution. Si le mutex est déjà occupé par un autre thread, le thread actuel est bloqué jusqu'à ce que le mutex soit libéré.
• unlock (déverrouillage) : Libération de la possession du mutex. Cela permet à un autre thread en attente de le prendre. Il est important que le mutex soit libéré par le même thread qui l'a acquis.

Par exemple, en Objective-C ou Swift, on peut utiliser NSLock pour travailler avec des mutex.

Exemple d'utilisation de NSLock en 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]; // Acquisition du mutex
    @try {
        // Travail avec _sharedResource - section critique
        _sharedResource++;
        NSLog(@"Ressource partagée mise à jour à %d par le thread %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Libération du mutex
    }
}

@end

Exemple d'utilisation de NSLock en Swift :

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Acquisition du mutex
        // Travail avec sharedResource - section critique
        sharedResource += 1
        print("Ressource partagée mise à jour à \(sharedResource) par le thread \(Thread.current)")
        lock.unlock() // Libération du mutex
    }
}

Les mutexes empêchent les conditions de course (race conditions) et assurent l'intégrité des données lors d'accès parallèles. Une mauvaise utilisation des mutex peut conduire à des blocages mutuels (deadlocks).