mutexes

A mutex, short for mutual exclusion, is a synchronization primitive used to protect shared data from concurrent access in multi-threaded programs. A thread must acquire the mutex before entering a critical section and release it when leaving. If another thread attempts to lock a held mutex, it blocks until the lock becomes available. Some mutexes are recursive, allowing the owning thread to lock multiple times; others are non-recursive and will deadlock if the owner re-acquires.

Mutexes can be blocking, where a waiting thread sleeps, or non-blocking (spin), where it busy-waits. Blocking mutexes save CPU time but incur context switches; spinlocks can be faster for very short waits but waste CPU cycles. Many systems offer fairness or priority policies to order waiting threads, while others are non-fair. Incorrect use can cause deadlocks, livelocks, or priority inversion, where a low-priority thread delays a high-priority one. Best practices include consistent lock order and, when supported, priority inheritance.

Common implementations include POSIX mutexes (pthread_mutex), Windows mutexes and critical sections, and language libraries such as C++ std::mutex, std::recursive_mutex, and Java's ReentrantLock or synchronized blocks. Mutexes have lifecycles: initialization, locking/unlocking, and destruction. They may provide attributes such as robustness (detecting owner crashes) or variants like recursive or error-checking. Alternatives include read-write locks for shared readers, lock-free data structures using atomic operations, and higher-level constructs like condition variables that coordinate complex synchronization.