Acquire semantics
Acquire semantics prevent subsequent memory operations from being reordered before an acquire operation and make visible effects that happen-before it, including those published by a synchronizing release operation.
C++ Concurrency in Action, Second Edition
An acquire operation is an atomic operation whose ordering can synchronize with a release operation on the same memory location.
- How it is used
- Orders access to protected data after locking and to published stack nodes before reading their fields.
- How deep it goes
- Works through happens-before chains for non-atomic data in a spinlock and ordering choices across stack compare-exchanges.
- Examples
- Uses an atomic_flag spinlock and a reference-counted lock-free stack with differently ordered successful and failed exchanges.
- What you can do after
- Apply it via std::atomic_flag or compare_exchange_strong to establish ordering before reading protected or published data.
Read how C++ Concurrency in Action, Second Edition explains acquire semantics →
Modern C
An acquire operation is a concurrency operation that establishes visibility of effects published by a corresponding release.
- How it is used
- Establishes when one thread can see effects published before another thread’s release operation.
- How deep it goes
- Defines synchronization through a read of a released value, then identifies atomic memory orders and library-call pairs.
- Examples
- Uses communicating threads and call_once initialization to show when earlier modifications become visible.
- What you can do after
- Apply it via C atomic memory orders or synchronizing library calls to determine when another thread’s earlier effects are visible.
Modern C, Third Edition
Acquire semantics are memory-ordering properties that make effects preceding a matching release operation visible after the acquire operation.
- How it is used
- Establishes when one thread can rely on effects produced by another after an atomic read or synchronizing library call.
- How deep it goes
- Defines synchronization through the value read and traces its visibility consequence, while deferring relaxed atomic operations.
- Examples
- Uses an atomic assignment and decrement, then identifies acquiring sides of `thrd_join`, `call_once`, and mutex acquisition.
- What you can do after
- Evaluate/understand it: identify when a matching acquire makes earlier effects of a releasing thread visible.
Read how Modern C, Third Edition explains acquire semantics →
Latency
An acquire memory barrier prevents subsequent memory operations from being reordered before a synchronization operation and observes effects published by a releasing operation.
- How it is used
- Orders reads after a synchronization signal so a consumer can use updates published by a producer.
- How deep it goes
- Defines the ordering guarantee, demonstrates a relaxed-order failure and repair, and applies it in queue operations without detailing architecture-specific instructions.
- Examples
- Uses a two-thread value-and-completion-flag test and a bounded single-producer, single-consumer queue.
- What you can do after
- Apply it via Rust atomic ordering to pair an acquire load with a publishing release store.
C# Concurrency: Asynchronous and multithreaded programming
Acquire semantics are memory-ordering guarantees that prevent reads from being moved earlier than a synchronization operation.
- How it is used
- Uses lock acquisition to make shared-memory reads safe against compiler and CPU reordering.
- How deep it goes
- Defines read-order constraints, contrasts release and barrier semantics, and stops short of detailed CPU-level implementation.
- Examples
- Uses shared initialization, lock acquisition and release, volatile access, and a diagram of reordered memory operations.
- What you can do after
- Apply lock-based synchronization when accessing data shared between threads.
Read how C# Concurrency: Asynchronous and multithreaded programming explains acquire semantics →
Related concepts
- acquire-release semanticsconfigures · Acquire-release semantics are memory-ordering rules under which release operations make preceding effects visible to acquire operations that synchronize with them.
- memory barrieruses · A memory barrier is a synchronization operation that constrains the ordering or visibility of memory accesses across concurrent execution.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.