spinlock

A spinlock is a synchronization primitive used in multithreading to protect shared data. A thread that tries to acquire a spinlock enters a loop, repeatedly checking the lock state until it becomes available. Because the thread does not sleep while waiting, it consumes CPU cycles; this busy-waiting behavior is the origin of the term spinning.

Operation is typically based on a simple flag stored in shared memory, implemented as an atomic variable. Acquisition uses an atomic operation such as test-and-set or compare-and-swap to set the flag to locked if it was unlocked. If another thread holds the lock, the operation fails and the thread continues spinning. The lock is released by clearing the flag, usually with a memory barrier to ensure that prior writes are visible to other processors.

Implementation notes include the need for proper memory-barrier semantics to guarantee visibility and ordering of memory accesses. Some spinlocks implement back-off strategies or yield the processor after a number of unsuccessful attempts to reduce contention. Spinlocks are generally best for short critical sections and on systems where threads cannot sleep safely or where blocking would be expensive.

Variants of spinlocks include ticket spinlocks, which grant access in a first-come, first-served order to improve fairness, and queue-based or adaptive spinlocks, which aim to reduce spinning under contention. Many systems provide spinlock primitives in their kernel or libraries, often with architecture-specific optimizations.

Usage considerations involve trade-offs between simplicity and CPU usage. In user-space programs, spinlocks are suitable when the protected section is very short or blocking would be costly. In kernel or real-time contexts, they may be used with care, sometimes with interrupts disabled. Spinlocks are generally not appropriate for long-running operations or where a thread may block.