C++
Acquire-release
Learn acquire-release semantics.
Acquire-release
The acquire-release model provides synchronization cheaper than seq_cst. It gives ordering only between paired release stores and acquire loads; it does not guarantee a total order.
One thread does flag.store(true, std::memory_order_release); the other, on seeing true via flag.load(std::memory_order_acquire), sees all writes the first thread did before the release. This is the common publish-then-observe pattern.
Publish-then-observe
A common use of acquire-release is the publish-then-observe pattern. Thread A prepares payload, then publishes flag with release. Thread B reads flag with acquire; on seeing true, payload is ready.
The difference from seq_cst: only this matched pair is ordered; other threads may see different order. But for most cases this is enough; performance is better.
Exercise Write publish-observe with acquire-release
Define a global std::atomic<bool> flag{false}; and int payload = 0;. In main write payload = 99;, then flag.store(true, std::memory_order_release);, then bool v = flag.load(std::memory_order_acquire); and std::cout << v;.
Show example solution
#include <iostream>
#include <atomic>
std::atomic<bool> flag{false};
int payload = 0;
int main() {
payload = 99;
flag.store(true, std::memory_order_release);
bool v = flag.load(std::memory_order_acquire);
std::cout << v;
return 0;
}
Test yourself
-
Complete the release store
flag.store(true, std::memory_order_____);
Show answer
flag.store(true, std::memory_order_release);
-
Match each ordering to its role
- store + release
- Write publishes
- load + acquire
- Read sees publishes
- relaxed
- No ordering guarantee
- seq_cst
- Total order guarantee
-
What guarantee does the acquire-release model provide?
flag.store(true, release);
bool v = flag.load(acquire);
- Ordering between paired write-read
- Total order across all threads
- No ordering guarantee
- Only single-thread order
Show answer
Ordering between paired write-read — Acquire-release gives ordering only between paired release-acquire operations.
Next lesson: Summary - Memory model
