This article explores the principles of spin locks and atomic operations in multithreaded programming, detailing their mechanisms, advantages, drawbacks, implementation examples in C++ and Java, and practical usage scenarios, while offering tips for effective and efficient synchronization.
This article explains the concept of spin locks, compares them with mutexes, shows how to use the pthread API and C++ atomic_flag to implement them, outlines suitable scenarios, highlights CPU‑usage pitfalls, and provides practical code examples.
The article compares spin_lock, rwlock, seqlock and RCU for protecting a shared kernel resource in a multi‑core embedded system, explains how RCU enables lock‑free reads, discusses the challenges of safe deletion, and outlines the RCU read‑copy‑update workflow.
This article explains the concept of spin locks, compares them with non‑spin locks, discusses their advantages and drawbacks, and provides Java code examples—including an AtomicLong implementation and a custom re‑entrant spin lock—to illustrate how spin locks work in concurrent programming.
The article explains what thread blocking means in operating systems, how the OS moves blocked threads to wait queues and schedules other threads, discusses spin locks, and reflects on common misconceptions and community debates about callbacks versus polling.
This article explains the fundamentals of the compare‑and‑swap (CAS) atomic primitive, how CPUs guarantee its atomicity through bus and cache locking, illustrates a Java spin‑lock implementation using CAS, and discusses typical issues such as single‑variable limitation, long spin times, and the ABA problem with mitigation strategies.
This article examines MySQL InnoDB spin‑lock tuning by adjusting innodb_spin_wait_delay and innodb_sync_spin_loops, describing spin‑lock mechanics, detailing an experiment with performance_schema metrics, and concluding that modest spin settings are preferable to aggressive tuning.
This article explains the fundamentals of spin locks, introduces the CLH lock as an improved spin‑lock variant, analyzes its Java implementation details, and describes how Java's AbstractQueuedSynchronizer refactors CLH locks to provide fair, low‑overhead synchronization for concurrent applications.
This article explains the concepts of spin locks and mutex locks, introduces the CLH lock as a fair spin lock used in Java's AbstractQueuedSynchronizer, and provides a detailed walkthrough of its Java implementation, initialization, lock and unlock processes, along with code examples and visual illustrations.
