Cos'è un mutex?

Il mutex (mutual exclusion) è un meccanismo di sincronizzazione utilizzato per proteggere una risorsa condivisa dall'accesso simultaneo da parte di più thread (o processi). In ogni momento, solo un thread può possedere il mutex e, di conseguenza, accedere alla risorsa protetta.

Operazioni principali con il mutex:

• lock (blocco): Tentativo di acquisire la proprietà del mutex. Se il mutex è libero, il thread lo acquisisce e continua l'esecuzione. Se è già occupato da un altro thread, il thread corrente viene bloccato fino a quando il mutex non viene rilasciato.
• unlock (sblocco): Rilascio della proprietà del mutex. Questo permette a un altro thread in attesa di acquisirlo. È importante che il mutex venga rilasciato dallo stesso thread che lo ha acquisito.

Ad esempio, in Objective-C o Swift, si può usare NSLock per lavorare con i mutex.

Esempio di utilizzo di 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]; // Acquisizione del mutex
    @try {
        // Lavoro con _sharedResource - sezione critica
        _sharedResource++;
        NSLog(@"Risorsa condivisa aggiornata a %d dal thread %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Rilascio del mutex
    }
}

@end

Esempio di utilizzo di NSLock in Swift:

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Acquisizione del mutex
        // Lavoro con sharedResource - sezione critica
        sharedResource += 1
        print("Risorsa condivisa aggiornata a \(sharedResource) dal thread \(Thread.current)")
        lock.unlock() // Rilascio del mutex
    }
}

I mutex prevengono le condizioni di race e garantiscono l'integrità dei dati durante accessi paralleli. Un uso scorretto dei mutex può portare a deadlock.