What is a mutex (mutual exclusion)?

Mutex (mutual exclusion) is a synchronization mechanism used to protect shared resources from concurrent access by multiple threads. It guarantees that at any given time, only one thread can own the mutex and thus access the protected resource.

Main operations with mutexes:

• Lock: A thread attempts to acquire the mutex. If the mutex is free, the thread successfully acquires it and continues execution. If the mutex is occupied by another thread, the current thread is blocked until the mutex is released.
• Unlock: The thread that owns the mutex releases it. If there are other threads waiting for this mutex, one of them (usually chosen according to the scheduler's policy) will be unblocked and able to acquire the mutex.

In Objective-C and Swift, mutexes can be implemented using various APIs, for example:

• NSLock or NSRecursiveLock in Foundation.
• POSIX mutexes (pthread_mutex_t).
• os_unfair_lock (a lower-level and high-performance lock for simple locking).

Example of usage in Objective-C with NSLock:

// Creating NSLock
NSLock *dataLock = [[NSLock alloc] init];

// ...

// Acquiring the mutex before accessing the shared resource
[dataLock lock];
// Access to the shared resource, e.g., modifying an array
// [sharedArray addObject:newItem];
// ...

// Releasing the mutex after finishing access
[dataLock unlock];

Example of usage in Swift with NSLock:

// Creating NSLock
let dataLock = NSLock()

// ...

// Acquiring the mutex before accessing the shared resource
dataLock.lock()
// Access to the shared resource, e.g., appending to an array
// sharedArray.append(newItem)
// ...

// Releasing the mutex after finishing access
dataLock.unlock()

Mutexes prevent race conditions, where access to shared data from multiple threads without synchronization can lead to unpredictable results or data corruption. Incorrect use of mutexes (e.g., deadlocks) can cause the application to hang.