源文：https://blog.csdn.net/K346K346/article/details/85345477?depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2&utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2

1.认识原子操作

原子操作是在多线程程序中“最小的且不可并行化的”操作，意味着多个线程访问同一个资源时，有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证，例如Linux下的互斥锁（mutex），Windows 下的临界区（Critical Section）等。下面看一个Linux环境使用 POSIX 标准的 pthread 库实现多线程下的原子操作：

#include <pthread.h>
#include <iostream>

using namespace std;
int64_t total=0;
pthread_mutex_t m=PTHREAD_MUTEX_INITIALIZER;

//线程函数，用于累加
void* threadFunc(void* args)
{
    int64_t endNum=*(int64_t*)args;
    for(int64_t i=1;i<=endNum;++i)
    {
        pthread_mutex_lock(&m);
        total+=i;
        pthread_mutex_unlock(&m);
    }
}

int main()
{
    int64_t endNum=100;
    pthread_t thread1ID=0,thread2ID=0;

    //创建线程1
    pthread_create(&thread1ID,NULL,threadFunc,&endNum);
    //创建线程2
    pthread_create(&thread2ID,NULL,threadFunc,&endNum);

    //阻塞等待线程1结束并回收资源
    pthread_join(thread1ID,NULL);
    //阻塞等待线程2结束并回收资源
    pthread_join(thread2ID,NULL);

    cout<<"total="<<total<<endl;    //10100
}

上面的代码，两个线程同时对 total 进行操作，为了保证total+=i的原子性，采用互斥锁来保证同一时刻只有同一线程执行total+=i操作，所以得出正确结果total=10100。如果没有做互斥处理，那么 total 同一时刻可能会被两个线程同时操作，即会出现两个线程同时读取了寄存器中的 total 值，分别操作之后又写入寄存器，这样就会有一个线程的增加操作无效，会得出一个小于 10100 随机的错误值。

2.C++11 实现原子操作

在 C++11 之前，使用第三方 API 可以实现并行编程，比如 pthread 多线程库，但是在使用时需要创建互斥锁，以及进行加锁、解锁等操作来保证多线程对临界资源的原子操作，这无疑增加了开发的工作量。不过从 C++11 开始，C++ 从语言层面开始支持并行编程，内容包括了管理线程、保护共享数据、线程间的同步操作、低级原子操作等各种类。新标准极大地提高了程序的可移植性，以前的多线程依赖于具体的平台，而现在有了统一的接口。

C++11 通过引入原子类型帮助开发者轻松实现原子操作。

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

using namespace std;
atomic_int64_t total = 0;
//atomic_int64_t相当于int64_t，但是本身就拥有原子性

//线程函数，用于累加
void threadFunc(int64_t endNum)
{
    for (int64_t i = 1; i <= endNum; ++i)
    {
        total += i;
    }
}

int main()
{
    int64_t endNum = 100;
    thread t1(threadFunc, endNum);
    thread t2(threadFunc, endNum);

    t1.join();
    t2.join();

    cout << "total=" << total << endl;    //10100
}

程序正常编译并运行输出正确结果total=10100。使用C++11提供的原子类型与多线程标准接口，简洁地实现了多线程对临界资源的原子操作。原子类型C++11中通过atomic<T>类模板来定义，比如atomic_int64_t是通过typedef atomic<int64_t> atomic_int64_t实现的，使用时需包含头文件<atomic>。除了提供atomic_int64_t，还提供了其它的原子类型。
常见的原子类型有：

原子操作是平台相关的，原子类型能够实现原子操作是因为 C++11 对原子类型的操作进行了抽象，定义了统一的接口，并要求编译器产生平台相关的原子操作的具体实现。C++11 标准将原子操作定义为 atomic 模板类的成员函数，包括读（load）、写（store）、交换（exchange）等。对于内置类型而言，主要是通过重载一些全局操作符来完成的。比如对上文total+=i的原子加操作，是通过对operator+=重载来实现的。使用g++ 编译的话，在 x86_64 的机器上，operator+=()函数会产生一条特殊的以 lock 为前缀的 x86_64 指令，用于控制总线及实现 x86_64平台上的原子性加法。

有一个比较特殊的原子类型是 atomic_flag，因为 atomic_flag 与其他原子类型不同，它是无锁（lock_free）的，即线程对其访问不需要加锁，而其他的原子类型不一定是无锁的。因为atomic并不能保证类型T是无锁的，另外不同平台的处理器处理方式不同，也不能保证必定无锁，所以其他的类型都会有 is_lock_free() 成员函数来判断是否是无锁的。atomic_flag 只支持 test_and_set() 以及 clear() 两个成员函数，test_and_set()函数检查 std::atomic_flag 标志，如果 std::atomic_flag 之前没有被设置过，则设置 std::atomic_flag 的标志；如果之前 std::atomic_flag 已被设置，则返回 true，否则返回 false。clear()函数清除 std::atomic_flag 标志使得下一次调用 std::atomic_flag::test_and_set()返回 false。可以用 atomic_flag 的成员函数test_and_set() 和 clear() 来实现一个自旋锁（spin lock）：

#include <unistd.h>
#include <atomic>
#include <thread>
#include <iostream>

std::atomic_flag lock = ATOMIC_FLAG_INIT;

void func1()
{
    while (lock.test_and_set(std::memory_order_acquire))    // 在主线程中设置为true，需要等待t2线程clear11    
    {
        std::cout << "func1 wait" << std::endl;
    }
    std::cout << "func1 do something" << std::endl;
}

void func2()
{
    std::cout << "func2 start" << std::endl;
    lock.clear();
}

int main()
{
    lock.test_and_set();             // 设置状态
    std::thread t1(func1);
    usleep(1);                        //睡眠1us
    std::thread t2(func2);

    t1.join();
    t2.join();

    return 0;
}

以上代码中，定义了一个 atomic_flag 对象 lock，使用初始值 ATOMIC_FLAG_INIT进行初始化，即处于 false 的状态。线程 t1 调用 test_and_set() 一直返回 true（因为在主线程中被设置过），所以一直在等待，而等待一段时间后当线程 t2 运行并调用了 clear()，test_and_set() 返回了 false 退出循环等待并进行相应操作。这样一来，就实现了一个线程等待另一个线程的效果。当然，可以封装成锁操作的方式，比如：

void Lock(atomic_flag& lock){ while ( lock.test_and_set()); }
void UnLock(atomic_flag& lock){ lock.clear(); }

这样一来，就可以通过Lock()和UnLock()的方式来互斥地访问临界区。

3.内存模型：强顺序与弱顺序

内存模型通常是硬件上的概念，表示的是机器指令是以什么样的顺序被处理器执行的，现代的处理器并不是逐条处理机器指令的：

Load    reg3, 1;           // 将立即数1放入寄存器reg3
Move    reg4,reg3;         // 将reg3的数据放入reg4
Store   reg4, a;           // 将reg4的数据存入内存地址a
Load    reg5, 2;           // 将立即数2放入寄存器reg5
Store   reg5, b;           // 将reg5的数据存入内存地址b

以上的伪汇编代码代表了temp = 1; a = temp; b = 2;，通常情况下指令都是按照1~5的顺序执行，这种内存模型称为强顺序(strong ordered)。不过可以看到，指令1、2、3和指令4、5的运行顺序不影响结果，有一些处理器可能会将指令的顺序打乱，例如按照1-4-2-5-3的顺序执行，这种内存模型称为弱顺序(weak ordered)。弱顺序内存模型下，指令5（b的赋值）很有可能在指令3（a的赋值）之前完成。

现实中，x86_64以及SPARC（TSO模式）都是采用强顺序内存模型的平台。在多线程程序中，强顺序类型意味着对于各个线程看到的指令执行顺序是一致的。对于处理器而言，内存中的数据被改变的顺序与机器指令中的一致。相反的，弱顺序就是各个线程看到的内存数据被改变的顺序与机器指令中声明的不一致。弱顺序内存模型可能会导致程序问题，为什么有些平台，诸如Alpha、PowerPC、Itanlium、ArmV7等平台会使用这种模型？简单地说，这种模型能让处理器有更好的并行性，提高指令执行的效率。并且，为了保证指令执行的顺序，通常需要在汇编指令中加入一条内存栅栏（memory barrier）指令，但是会影响处理器性能。比如在PowerPC上，就有一条名为sync的内存栅栏指令。该指令迫使已经进入流水线中的指令都完成后处理器才会执行sync以后的指令。

事实上，C++11中的原子操作还可以包含一个参数：内存顺序（memory_order），是C++11为原子类型定义的内存模型，让程序员根据实际情况灵活地控制原子类型的执行顺序。通常情况下，使用该参数将有利于编译器进一步提高并行性能。

atomic<int> a{0};
atomic<int> b{0};

//线程函数
int valueSet(int)
{
    int t=1;
    a.store(t);
    b.store(2);
}

如果原子类型变量a和b并没有要求执行的顺序性，那么可以采用一种松散的内存模型来放松对原子操作的执行顺序的要求。改造如下：

void func1()
{
    int t=t;
    a.store(t, std::memory_order_relaxed);
    b.store(2, std::memory_order_relaxed);
}

上面的代码使用了store函数进行赋值，store函数接受两个参数，第一个是要写入的值，第二个是名为memory_order的枚举值。这里使用了std::memory_order_relaxed，表示松散内存顺序，该枚举值代表编译器可以任由编译器重新排序或则由处理器乱序处理。这样a和b的赋值执行顺序性就被解除了。在C++11中一共有7种memory_order枚举值，默认按照memory_order_seq_cst执行：

需要注意的是，不是所有的memory_order都能被atomic成员使用：

1. store函数可以使用memory_order_seq_cst、memory_order_release、memory_order_relaxed。
2. load函数可以使用memory_order_seq_cst、memory_order_acquire、memory_order_consume、memory_order_relaxed。
3. 需要同时读写的操作，例如test_and_flag、exchange等操作。可以使用memory_order_seq_cst、memory_order_release、memory_order_acquire、memory_order_consume、memory_order_relaxed。

原子类型提供的一些操作符，比如operator=、operator+=等函数，都是以memory_order_seq_cst为memory_order的实参的原子操作封装，所以他们都是顺序一致性的。如果要指定内存顺序的话，则应该采用store、load、atomic_fetch_add这样的版本。

最后说明一下，std::atomic和std::memory_order只有在多线程无锁编程时才会用到。在x86_64平台，由于是强顺序内存模型的，为了保险起见，不要使用std::memory_order，使用std::atmoic默认形式即可，因为std::atmoic默认是强顺序内存模型。