Day 49 — The C++ Memory Model and Memory Ordering

1. Problem It Solves

The memory model defines inter-thread visibility and ordering; release and acquire operations can publish ordinary data through an atomic synchronization point. It makes an important constraint visible instead of leaving readers to guess. This lesson keeps only the C++11 core that fits one focused day.

2. Prerequisites

The ideas from Day 48, plus basic variables, functions, and output already introduced.

3. Core Idea

Mental model: The memory model defines inter-thread visibility and ordering; release and acquire operations can publish ordinary data through an atomic synchronization point. Identify the relevant value or state, who owns it, and whether the rule acts during compilation or execution.

4. Minimal Syntax

ready.store(true, std::memory_order_release); ready.load(std::memory_order_acquire);

5. How It Works

The example creates a tiny fixed state with no keyboard input.
C++11 or the standard-library contract applies today's rule.
The program prints the important result so it can be checked against the source.

6. Common Mistakes

Using memory_order_relaxed for a publication flag does not make earlier non-atomic payload writes visible to the reader.

7. When to Use It

Use it when building a proven synchronization relation around atomic state.
Avoid it when it hides ownership, lifetime, type, ordering, or cost.

8. Simple Example

One thread writes payload then releases a ready flag; another acquires the flag before reading the payload safely. The .cpp keeps the data fixed and avoids unrelated abstraction.

Complete sample code

Source file

cpp11/49_memory_model_memory_ordering/main.cpp

C++

#include <atomic>
#include <iostream>
#include <thread>

int main() {
    int payload = 0;
    std::atomic<bool> ready(false);

    std::thread writer([&] {
        payload = 42;
        ready.store(true, std::memory_order_release);
    });

    std::thread reader([&] {
        while (!ready.load(std::memory_order_acquire)) {
        }
        std::cout << "payload=" << payload << '\n';
    });

    writer.join();
    reader.join();
}

9. Key Takeaways

The feature is part of the C++11 scope used in this course.
Understand its lifetime, ownership, type, and ordering consequences.
Compile with warnings and prefer the smallest form that makes the rule obvious.

10. Self-Check Questions

Easy — One thread writes payload, then calls ready.store(true, std::memory_order_release). Another reads payload only after ready.load(std::memory_order_acquire) reads true from that store. What does release/acquire guarantee?
Medium — Read the small example described above. What value or state should it print, and which rule produces that result?
Hard — Find and explain the subtle bug in this situation: Using memory_order_relaxed for a publication flag does not make earlier non-atomic payload writes visible to the reader. What is the smallest C++11-safe correction?

Practice this lesson's cards

1. Problem It Solves

#include <atomic> #include <iostream> #include <thread> int main() { int payload = 0; std::atomic<bool> ready(false); std::thread writer([&] { payload = 42; ready.store(true, std::memory_order_release); }); std::thread reader([&] { while (!ready.load(std::memory_order_acquire)) { } std::cout << "payload=" << payload << '\n'; }); writer.join(); reader.join(); }

10. Self-Check Questions

Easy — One thread writes payload, then calls ready.store(true, std::memory_order_release). Another reads payload only after ready.load(std::memory_order_acquire) reads true from that store. What does release/acquire guarantee?
Medium — Read the small example described above. What value or state should it print, and which rule produces that result?
Hard — Find and explain the subtle bug in this situation: Using memory_order_relaxed for a publication flag does not make earlier non-atomic payload writes visible to the reader. What is the smallest C++11-safe correction?