原子操作就是在多线程程序中”最小的且不可并行化的”操作，意味着多个线程访问同一个资源时，有且仅有一个线程能对资源进行操作。通常情况下原子操作可以通过互斥的访问方式来保证，例如Linux下的互斥锁，Windows下的临界区等。下面让我们看个例子：
long long total = 0;
void func()
{
for (long long i = 0; i < 100000000LL; ++i)
{
total += i;
}
}
int main(void)
{
std::thread t1(func); // C++11中的线程，后续介绍，相当于创建了一个线程
std::thread t2(func);
t1.join();
t2.join();
std::cout << total << std::endl; // 结果未知，会小于等于9999999900000000
return 0;
}上面的代码，两个线程同时对total进行操作，并且没有做互斥来保证同步。如果做了互斥，也就是total不会被两个线程同时操作，那么结果会等于9999999900000000。但是因为没有做互斥，就会出现两个线程同时读取了寄存器中的值，分别操作之后又写入寄存器，这样就会有一个线程的增加操作无效，所以得出的结果就会小于9999999900000000，且结果未知。在C++11以前，我们可以通过互斥来保证两个线程不会同时操作total，例如：
long long total = 0;
mutex total_mutex; // 伪代码
void func()
{
for (long long i = 0; i < 100000000LL; ++i)
{
lock(total_mutex);
total += i; // 通过互斥量保证了total不会被同时访问
unlock(total_mutex);
}
}
int main(void)
{
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
std::cout << total << std::endl; // 9999999900000000
return 0;
}这样能保证线程间的同步，但是如果资源需要在多个地方进行操作，就需要频繁的lock和unlock，所以在C++11中新增了原子类型，让代码更加简洁：
std::atomic_llong total = 0; // atomic_llong相当于long long，但是本身就拥有原子性
void func()
{
for (long long i = 0; i < 100000000LL; ++i)
{
total += i;
}
}
int main(void)
{
std::thread t1(func);
std::thread t2(func);
t1.join();
t2.join();
std::cout << total << std::endl; // 9999999900000000
return 0;
}
可以看到，使用了原子类型atomic_llong之后，不需要使用额外的互斥接口来保证total的同步，total自身就能保证。除了atomic_llong类型，C++11还提供了其他的原子类型。
当我们去看这些类型的定义时会发现，起始它们都是用atomic<T>模板来定义的。例如std::atomic_llong就是用std::atomic<long long>来定义的。
原子类型支持的原子操作
C++11中将原子操作定义为atomic模板类的成员函数，包括了大多数类型的操作，比如读写、交换等。对于内置类型，主要通过重载全局操作符来实现。下面列出所有atomic类型及其支持的相关操作列表：
列表中的atomic-intergral-type以及atomic<intergral-type>就是前面的原子类型列表中的类型，class-type是自定义类型。对于大部分原子类型，都支持读(load)、写(store)、交换(exchange)等操作：
std::atomic<int> n = 0;
int a = n; // 相当于int a = n.load();
n = 1; // 相当于a.store(1);
int b = n.exchange(1); // n赋值为1，返回n原来的值另外，列表中有一个比较特殊的atomic_flag类型，atomic_flag与其他类型不同，它是无锁(lock_free)的，而其他的类型不一定是无锁的。因为，atomic<T>并不能保证类型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 对象是否被设置过，如果之前 std::atomic_flag 对象已被设置，则返回 true，否则返回 false；clear函数清除 std::atomic_flag 标志使得下一次调用 std::atomic_flag::test_and_set 返回 false。可以用这两个函数来实现一个自旋锁：
void func1()
{
while (flag.test_and_set(std::memory_order_acquire)) // 在主线程中设置为true，需要等待t2线程clear
{
std::cout << "wait" << std::endl;
}
std::cout << "do something" << std::endl;
}
void func2()
{
std::cout << "start" << std::endl;
flag.clear();
}
int main(void)
{
flag.test_and_set(); // 设置状态
std::thread t1(func1);
Sleep(10);
std::thread t2(func2);
t1.join();
t2.join();
return 0;
}以上代码中，线程t1调用test_and_set一直返回true(因为在主线程中被设置过)，所以一直在等待，而等待一段时间后当线程t2运行并调用了clear，test_and_set返回了false退出循环等待并进行相应操作。这样一来，就实现了一个线程等待另一个线程的效果。
内存模型、顺序一致性和memory_order
了解这一小节的内容之前，先看一段代码：
void func1()
{
a = 1;
b = 2;
}
void func2()
{
std::cout << a << "," << b << std::endl; // 不定
}
int main(void)
{
std::thread t1(func1);
std::thread t2(func2);
t1.join();
t2.join();
std::cout << a << "," << b << std::endl; // 1,2
return 0;
}以上的代码，在主线程中打印a和b结果必定是1,2，而在线程func2中打印结果就不一定了，可能是0,0或者1,2或者1,0。因为线程的执行并不能保证先创建的一定先原先，两者运行顺序存在多种可能。但是对于原子类型来说，func2中的打印不可能出现0,2的情况，因为原子类型的变量在线程中总是保持顺序执行的特性(顺序一致性)。
不过在C++11中顺序一致性只是多种内存模型中的一种，代码并非必须按照顺序执行，因为顺序往往意味着最低效的同步方式。在了解其他内存模型之前，我们需要先了解一些处理器和编译器相关的知识。内存模型通常是硬件上的概念，表示的是机器指令是以什么样的顺序被处理器执行的，现代的处理器并不是逐条处理机器指令的：
1: Load reg3, 1; // 将立即数1放入寄存器reg3
2: Move reg4,reg3; // 将reg3的数据放入reg4
3: Store reg4, a; // 将reg4的数据存入内存地址a
4: Load reg5, 2; // 将立即数2放入寄存器reg5
5: 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)。
在多线程程序中，强顺序类型意味着对于各个线程看到的指令执行顺序是一致的。对于处理器而言，看到内存中的数据被改变的顺序与机器指定中的一致。相反的，弱顺序就是各个线程看到的内存数据被改变的顺序与机器指定中声明的不一致。如果一个平台是弱顺序内存模型，那么上文打印a，b的代码中，线程func2就有可能打印出0,2的结果。既然弱顺序内存模型可能会导致程序问题，为什么有些平台会使用这种模型？简单的说，这种模型能让处理器有更好的并行性，提高指令执行的效率。并且，汇编指令中有一条内存栅栏指令，能保证指令的顺序执行，但是会影响处理器性能。
介绍了硬件内存模型后，再来说说C++11中定义的内存模型和顺序一致性和硬件中的关系。高级语言和机器指令是通过编译器来进行转换的，而编译器处于代码优化的考虑，会将指令进行移动。对于C++11的内存模型而言，要保证代码的顺序一致性，需要同时做到以下几点：
- 编译器保证原子操作的指令间顺序不变，即产生的读写原子类型变量的机器指令和代码编写顺序是一样的。
- 处理器对原子操作的汇编指令的执行顺序不变。这对于x86这样的强顺序的体系结构而言没有任何问题，而对于一些弱顺序的平台则需要妹子原子操作之后要加入内存栅栏。
对于上文打印a，b的代码来说，如果只需要在主线程中打印结果，那么代码的执行顺序并不重要。但是atomic原子类型默认的顺序一致性会要求编译器禁用优化，这无疑增加了性能开销。于是C++11中，设计了能够对原子类型指定内存顺序memory_order。我们把上文打印a，b的代码中的func1做一下修改：
void func1()
{
a.store(1, std::memory_order_relaxed);
b.store(2, std::memory_order_relaxed);
}上面的代码使用了store函数进行赋值，store函数接受两个参数，第一个是要写入的值，第二个是名为memory_order的枚举值。这里使用了std::memory_order_relaxed，表示松散内存顺序，该枚举值代表编译器可以任由编译器重新排序或则由处理器乱序处理。这样a和b的赋值执行顺序性就被解除了，对于func2中的打印语句，打印出0,2的结果也就是合理的了。在C++11中一共有7种memory_order枚举值，默认按照memory_order_seq_cst执行：
需要注意的是，不是所有的memory_order都能被atomic成员使用：
- store函数可以使用memory_order_seq_cst、memory_order_release、memory_order_relaxed。
- load函数可以使用memory_order_seq_cst、memory_order_acquire、memory_order_consume、memory_order_relaxed。
- 需要同时读写的操作，例如test_and_flag、exchange等操作。可以使用memory_order_seq_cst、memory_order_rel、memory_order_release、memory_order_acquire、memory_order_consume、memory_order_relaxed。
原子类型提供的一些操作符都是memory_order_seq_cst的封装，所以他们都是顺序一致性的。
最后说明一下，std::atomic和std::memory_order只有在多cpu多线程情况下，无锁编程才会用到。在x86下，由于是strong memory order的，所以很多时候只需要考虑编译器优化；保险起见，可以用std::atomic，他会同时处理编译器优化和cpu的memory order（虽然x86用不到）。但是在除非必要的情况下，不用使用std::memory_order，std::atmoic默认用的是最强限制。