C++ 11 中的内存模型

// C++ program to illustrate the concept of an atomic 
// operation using std::atomic. 
include <atomic> 
include <iostream> 
include <thread> 

using namespace std; 

// 原子变量确保原子操作 ；
atomic<int> counter(0); 

// 在循环中递增计数器的函数 
void incrementCounter() 
{ 
    for (int i = 0; i < 10000; ++i) { 
        counter.fetch_add(1, memory_order_relaxed); 
        // 使用 fetch_add 原子式递增计数器
     // memory_order_relaxed 用于最小化 
     //同步开销 ；
    } 
} 

// driver code 
int main() 
{ 
    // 创建一个线程，用于递增计数器 ；
    thread t1(incrementCounter); 
    // 创建另一个线程来递增计数器 ；
    thread t2(incrementCounter); 

    t1.join(); //等待第一条线程结束 ；
    t2.join(); // 等待第二个线程结束 ；

    //在两个 
    //线程都结束后，打印计数器的最终值；
    cout << "Counter value: "
        << counter.load(memory_order_relaxed) << endl; 

    return 0; 
}

// C++ program to illustrate the sequential consistency 
include <atomic> 
include <iostream> 
include <thread> 
using namespace std; 

// 声明原子整数 x 和 y，初始化为 0 ；
atomic<int> x(0), y(0); 

// 声明整数 res1 和 res2 以存储结果 ；
int res1, res2; 

// first thread callable 
void thread1() 
{ 
    // 在 x 中存储 1，并保持顺序一致性 ；
    x.store(1, memory_order_seq_cst); 
    //以顺序  一致性 将 y 的值加载到 res1 中；
    res1 = y.load(memory_order_seq_cst); 
} 

// 定义第二个线程的函数 ；
void thread2() 
{ 
    //在 y 中存储 1，并保持顺序一致性 ；
    y.store(1, memory_order_seq_cst); 
    //以顺序   一致性 将 x 的值加载到 res2 中；
    res2 = x.load(memory_order_seq_cst); 
} 

// Main function 
int main() 
{ 
    // 创建两个线程 t1 和 t2 ；
    thread t1(thread1); 
    thread t2(thread2); 

    //等待两个线程结束 ；
    t1.join(); 
    t2.join(); 

    cout << "res1: " << res1 << endl; 
    cout << "res2: " << res2 << endl; 
    // 可能的结果： res1 == 1 && res2 == 1， res1 == 0 ；
    //res1 和 res2 都为 0 是不可能的，因为这将违反顺序一致性 ；
}

// C++ program to illustrate the concept of memory ordering. 
include <atomic> 
include <iostream> 
include <thread> 
using namespace std; 

atomic<int> x(0); 
atomic<int> y(0); 

// 用函数将值写入 x 和 y，并放宽内存 
//排序 ；
void wr() 
{ 
    x.store(1, memory_order_relaxed); 
    y.store(1, memory_order_relaxed); 
} 

// 从 x 和 y 处读取值的函数，内存宽松 
// 排序 ；
void rd() 
{ 
    while (y.load(memory_order_relaxed) != 1) { 
       // 一直转到 y 被其他线程写入为止 
      // Memory_order_relaxed 用于最小化 
      // 同步开销 ；
    } 
    if (x.load(memory_order_relaxed) == 1) { 
        // Check if both x and y are 1 
        cout << "x and y are both 1" << endl; 
    } 
} 

int main() 
{ 
    thread t1(wr); // Create a thread for writing values 
    thread t2(rd); // Create a thread for reading values 

    t1.join(); // Wait for the writing thread to finish 
    t2.join(); // Wait for the reading thread to finish 

    return 0; 
}