原子操作 . 原理与底层实现

一.概述

原子操作（atomic operation）指的是由多步操作组成的一个操作。如果该操作不能原子地执行，则要么执行完所有步骤，要么一步也不执行，不可能只执行所有步骤的一个子集。

现代操作系统中，一般都提供了原子操作来实现一些同步操作，所谓原子操作，也就是一个独立而不可分割的操作。在单核环境中，一般的意义下原子操作中线程不会被切换，线程切换要么在原子操作之前，要么在原子操作完成之后。更广泛的意义下原子操作是指一系列必须整体完成的操作步骤，如果任何一步操作没有完成，那么所有完成的步骤都必须回滚，这样就可以保证要么所有操作步骤都未完成，要么所有操作步骤都被完成。

例如在单核系统里，单个的机器指令可以看成是原子操作（如果有编译器优化、乱序执行等情况除外）；在多核系统中，单个的机器指令就不是原子操作，因为多核系统里是多指令流并行运行的，一个核在执行一个指令时，其他核同时执行的指令有可能操作同一块内存区域，从而出现数据竞争现象。多核系统中的原子操作通常使用内存栅障（memory barrier）来实现，即一个CPU核在执行原子操作时，其他CPU核必须停止对内存操作或者不对指定的内存进行操作，这样才能避免数据竞争问题。

在C++11之前，C++标准中并没有对原子操作进行规定。vs和gcc编译器提供了原子操作的api。

二.原子操作的底层实现

实现方式：基于缓存加锁与总线加锁。

1.总线加锁

所谓总线锁就是使用处理器提供的一个lock#信号，当一个处理器在总线上输出此信号时，其他处理器的请求会被阻塞住，那么该处理器可以独占共享内存。

但总线锁定把cpu和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以开销比较大。

2.缓存加锁

第二个机制是通过缓存锁定来保证原子性。在同一时刻，我们只需保证对某个内存地址的操作是原子性即可，但总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。

频繁使用的内存会缓存在处理器的L1、L2和L3高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线锁，在Pentium 6和目前的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。所谓“缓存锁定”是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效，在如图2-3所示的例子中，当CPU1修改缓存行中的i时使用了缓存锁定，那么CPU2就不能同时缓存i的缓存行。
但是有两种情况下处理器不会使用缓存锁定。
第一种情况是：当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行（cache line）时，则处理器会调用总线锁定。
第二种情况是：有些处理器不支持缓存锁定。对于Intel 486和Pentium处理器，就算锁定的内存区域在处理器的缓存行中也会调用总线锁定。
针对以上两个机制，我们通过Intel处理器提供了很多Lock前缀的指令来实现。例如，位测试和修改指令：BTS、BTR、BTC；交换指令XADD、CMPXCHG，以及其他一些操作数和逻辑指令（如ADD、OR）等，被这些指令操作的内存区域就会加锁，导致其他处理器不能同时访问它。

三.编程使用

windows原子操作API：
Win32 API中常用的原子操作主要有三类，一种是加1减1操作，一种是比较交换操作，另外一种是赋值（写）操作。

（1）原子加1减1操作

LONG InterlockedIncrement( LONG volatile* Addend);
LONG InterlockedDecrement( LONG volatile* Addend);

（2）  比较并交换操作
 

LONG InterlockedCompareExchange( LONG volatile*Destination, LONG Exchange, LONG Comperand );

这个操作是先将Comperand的值和Destination指向变量的值进行比较，如果相等就将Exchange变量的值赋给Destination指向的变量。返回值为未修改前的Destination位置的初始值。

（3）原子写操作
 

LONG InterlockedExchange( LONG volatile* Target, LONG Value);

InterlockedExchange的作用为将Value的值赋给Target指向的变量，返回Target指向变量未被赋值前的值。

GCC编译器提供的原子操作API：
 

type __sync_fetch_and_add (type *ptr, type value);
type __sync_fetch_and_sub (type *ptr, type value);
type __sync_fetch_and_or (type *ptr, type value);
type __sync_fetch_and_and (type *ptr, type value);
type __sync_fetch_and_xor (type *ptr, type value);
type __sync_fetch_and_nand (type *ptr, type value);
type __sync_add_and_fetch (type *ptr, type value);
type __sync_sub_and_fetch (type *ptr, type value);
type __sync_or_and_fetch (type *ptr, type value);
type __sync_and_and_fetch (type *ptr, type value);
type __sync_xor_and_fetch (type *ptr, type value);
type __sync_nand_and_fetch (type *ptr, type value);

C++11提供的原子操作：
C++11中在<atomic>中定义了atomic模板类，atomic的模板参数类型可以为int、long、bool等等，C++中称为trivially copyable type。atomic_int、atomic_long为atomic模板实例化后的宏定义。atomic具体的原子操作函数可以参考http://www.cplusplus.com/reference/atomic/atomic/?kw=atomic。

代码：

#include <stdio.h>


#if 0

gcc数值原子操作API原理及应用
n++类：
	type __sync_fetch_and_add(type* ptr, type value, ...);// m+n
	type __sync_fetch_and_sub(type* ptr, type value, ...);// m-n
	type __sync_fetch_and_or(type* ptr, type value, ...);  // m|n
	type __sync_fetch_and_and(type* ptr, type value, ...);// m&n
	type __sync_fetch_and_xor(type* ptr, type value, ...);// m^n
	type __sync_fetch_and_nand(type* ptr, type value, ...);// (~m)&n
	/* 对应的伪代码 */
	{tmp = *ptr; *ptr op = value; returntmp; }
	{tmp = *ptr; *ptr = (~tmp) & value; returntmp; }   // nand

++n类：
	type __sync_add_and_fetch(type* ptr, type value, ...);// m+n
	type __sync_sub_and_fetch(type* ptr, type value, ...);// m-n
	type __sync_or_and_fetch(type* ptr, type value, ...);// m|n
	type __sync_and_and_fetch(type* ptr, type value, ...);// m&n
	type __sync_xor_and_fetch(type* ptr, type value, ...);// m^n
	type __sync_nand_and_fetch(type* ptr, type value, ...);// (~m)&n
	/* 对应的伪代码 */
	{*ptr op = value; return*ptr; }
	{*ptr = (~*ptr) & value; return*ptr; }// nand

CAS类：
	bool__sync_bool_compare_and_swap(type* ptr, type oldval, type newval, ...);
	type __sync_val_compare_and_swap(type* ptr, type oldval, type newval, ...);
	/* 对应的伪代码 */
	{if (*ptr == oldval) { *ptr = newval; returntrue; } else { returnfalse; }}
	{if (*ptr == oldval) { *ptr = newval; }returnoldval; }

#endif

int main() 
{
	int num = 0;

	/*
	 * n++;
	 * __sync_fetch_and_add(10, 3) = 10
	 * num = 13
	 */

	num = 10;
	printf("__sync_fetch_and_add(%d, %d) = %d\n", 10, 3, __sync_fetch_and_add(&num, 3));
	printf("num = %d\n", num);

	/*
	 * ++n;
	 * __sync_and_add_and_fetch(10, 3) = 13
	 * num = 13
	 */

	num = 10;
	printf("__sync_and_add_and_fetch(%d, %d) = %d\n", 10, 3, __sync_add_and_fetch(&num, 3));
	printf("num = %d\n", num);

	/*
	 * CAS, match
	 * __sync_val_compare_and_swap(10, 10, 2) = 10
	 * num = 2
	 */

	num = 10;
	printf("__sync_val_compare_and_swap(%d, %d, %d) = %d\n", 10, 10, 2, __sync_val_compare_and_swap(&num, 10, 2));
	printf("num = %d\n", num);

	/*
	 * CAS, not match
	 * __sync_val_compare_and_swap(10, 3, 5) = 10
	 * num = 10
	 */

	num = 10;
	printf("__sync_val_compare_and_swap(%d, %d, %d) = %d\n", 10, 3, 5, __sync_val_compare_and_swap(&num, 1, 2));
	printf("num = %d\n", num);

	return 0;
}