Mutex

A mutex, short for mutual exclusion, is a synchronization primitive used in concurrent programming to protect access to shared resources. It allows only one thread at a time to access the protected resource, ensuring that operations on the resource are performed atomically and without interference from other threads.

How it works: A thread requests the mutex by locking it. If the mutex is free, the thread becomes the owner and can proceed with the protected critical section. If the mutex is already locked by another thread, the requesting thread blocks until the mutex is released. After completing the protected work, the owning thread unlocks the mutex, which typically wakes one of the waiting threads. Some mutexes are recursive, permitting the owning thread to lock multiple times; others are non-recursive and may deadlock if the owner attempts to re-lock. Many implementations also provide non-blocking try-lock and, in some cases, timed wait variants.

Variants and features: Try-lock attempts to acquire the mutex without blocking and returns immediately if it is unavailable. Timed or timed-lock variants wait for a specified duration. Priority inheritance or priority ceiling options can be used to mitigate priority inversion, a situation where high-priority threads are blocked by lower-priority ones holding the mutex. Some mutexes are robust and detect owner termination, enabling recovery or fallback behavior.

Design considerations: Mutexes are essential for data integrity but can introduce deadlocks, livelocks, or priority inversion if misused. Best practices include acquiring locks in a consistent global order, keeping critical sections short, and avoiding holding multiple mutexes simultaneously whenever possible. Language and library ecosystems provide mutex implementations, such as POSIX pthread_mutex_t in Unix-like systems and synchronization primitives like CRITICAL_SECTION or Mutex objects in Windows; many systems use kernel-supported mechanisms (for example, futex-based implementations on Linux).

Related concepts include spinlocks and read-write locks, which offer alternative trade-offs between latency and CPU usage.