Concurrency - Locks, Semaphores & Deadlock Prevention

A strategy that eliminates the Circular Wait condition by establishing a global strict ordering of resources ($R_1<R_2<\cdots <R_n$) and requiring threads to always acquire resources in increasing order.

A flaw in a concurrent system where the output or behavior is non-deterministic and depends unexpectedly on the sequence or timing of execution threads.

A segment of code that accesses a shared resource (such as global variables or shared memory) that must not be concurrently accessed by more than one thread of execution.

A locking mechanism used to synchronize access to a resource, ensuring that only one process or thread can execute a critical section at any given time.

A synchronization lock where a thread repeatedly polls the lock status in a tight loop (busy-waiting) until it becomes available. Efficient when context switching overhead exceeds expected wait time.

A lock that allows a thread to re-acquire a lock it already holds without deadlocking itself. It tracks an internal lock count and requires an equivalent number of unlocks to be released.

A mutex enforces strict ownership—only the thread that acquired the lock can release it. A binary semaphore has no concept of ownership; any thread can call signal() to unblock a waiting thread.

A semaphore initialized with an integer counter $N>1$, used to control access to a finite pool of $N$ identical resources.