O que é um mutex?

O mutex (exclusão mútua) é um mecanismo de sincronização utilizado para proteger um recurso partilhado contra acessos simultâneos de múltiplos threads (ou processos). Em cada momento, apenas um thread pode possuir o mutex e, consequentemente, aceder ao recurso protegido.

Operações principais com o mutex:

• lock (bloqueio): Tentativa de adquirir a posse do mutex. Se o mutex estiver livre, o thread obtém-no e continua a execução. Se já estiver ocupado por outro thread, o thread atual fica bloqueado até que o mutex seja libertado.
• unlock (desbloqueio): Liberta a posse do mutex. Isto permite que outro thread em espera o adquira. É importante que o mutex seja libertado pelo mesmo thread que o adquiriu.

Por exemplo, em Objective-C ou Swift, pode-se usar NSLock para trabalhar com mutexes.

Exemplo de uso de NSLock em 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]; // Bloqueia o mutex
    @try {
        // Trabalha com _sharedResource - secção crítica
        _sharedResource++;
        NSLog(@"Recurso partilhado atualizado para %d pelo thread %@", _sharedResource, [NSThread currentThread]);
    }
    @finally {
        [_lock unlock]; // Liberta o mutex
    }
}

@end

Exemplo de uso de NSLock em Swift:

// Swift
import Foundation

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

    func updateSharedResource() {
        lock.lock() // Bloqueia o mutex
        // Trabalha com sharedResource - secção crítica
        sharedResource += 1
        print("Recurso partilhado atualizado para \(sharedResource) pelo thread \(Thread.current)")
        lock.unlock() // Liberta o mutex
    }
}

Os mutexes evitam condições de corrida (race conditions) e garantem a integridade dos dados em acessos paralelos. Uso incorreto de mutexes pode levar a deadlocks (interbloqueios).