Memory Ordering

To optimize performance, compilers and CPUs reorder memory operations. In multi-threaded applications, you specify Memory Ordering on atomic operations to ensure threads see writes in the correct order.

Acquire-Release Semantics

Acquire-release ordering is a common way to synchronize threads without using full sequential consistency:

• Release: When a thread stores a value using memory_order_release, all its previous writes (even non-atomic ones) become visible to other threads.
• Acquire: When a thread reads that value using memory_order_acquire, it is guaranteed to see all memory writes that occurred before the release store.

Code Walkthrough

Implementing a thread-safe message pass using acquire-release memory ordering.

#include <iostream>
#include <atomic>
#include <thread>
#include <string>
std::atomic<bool> g_ready(false);
std::string g_data;
void producer() {
    g_data = "Secret message payload"; // Non-atomic write
    // Release: ensures data write is visible to acquire reads
    g_ready.store(true, std::memory_order_release); 
}
void consumer() {
    // Acquire: blocks until ready is true and synchronizes previous writes
    while (!g_ready.load(std::memory_order_acquire)) {
        // Spin lock
    }
    std::cout << "Consumer read: " << g_data << std::endl;
}
int main() {
    std::thread t1(consumer);
    std::thread t2(producer);
    t1.join();
    t2.join();
    return 0;
}

Interview-Relevant Information