原子&＃xff08;atom&＃xff09;本意是“不能被进一步分割的最小粒子”&＃xff0c;而原子操作&＃xff08;atomic operation&＃xff09;意为"不可被中断的一个或一系列操作" 。在多处理器上实现原子操作就变得有点复杂。本文让我们一起来聊一聊在Intel处理器和Java里是如何实现原子操作的。

java的原子性操作有哪些
Java中的原子操作包括&＃xff1a;
1&＃xff09;除long和double之外的基本类型的赋值操作
2&＃xff09;所有引用reference的赋值操作
3&＃xff09;java.concurrent.Atomic.* 包中所有类的一切操作
count&＃43;&＃43;不是原子操作&＃xff0c;是3个原子操作组合
1.读取主存中的count值&＃xff0c;赋值给一个局部成员变量tmp
2.tmp&＃43;1
3.将tmp赋值给count
可能会出现线程1运行到第2步的时候&＃xff0c;tmp值为1&＃xff1b;这时CPU调度切换到线程2执行完毕&＃xff0c;count值为1&＃xff1b;切换到线程1&＃xff0c;继续执行第3步&＃xff0c;count被赋值为1------------结果就是两个线程执行完毕&＃xff0c;count的值只加了1&＃xff1b;
还有一点要注意&＃xff0c;如果使用AtomicInteger.set(AtomicInteger.get() &＃43; 1)&＃xff0c;会和上述情况一样有并发问题&＃xff0c;要使用AtomicInteger.getAndIncrement()才可以避免并发问题

2. 术语定义

3. 处理器如何实现原子操作

32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作。

3.1 处理器自动保证基本内存操作的原子性

首先处理器会自动保证基本的内存操作的原子性。处理器保证从系统内存当中读取或者写入一个字节是原子的&＃xff0c;意思是当一个处理器读取一个字节时&＃xff0c;其他处理器不能访问这个字节的内存地址。奔腾6和最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位的操作是原子的&＃xff0c;但是复杂的内存操作处理器不能自动保证其原子性&＃xff0c;比如跨总线宽度&＃xff0c;跨多个缓存行&＃xff0c;跨页表的访问。但是处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。

3.2 使用总线锁保证原子性

第一个机制是通过总线锁保证原子性。如果多个处理器同时对共享变量进行读改写&＃xff08;i&＃43;&＃43;就是经典的读改写操作&＃xff09;操作&＃xff0c;那么共享变量就会被多个处理器同时进行操作&＃xff0c;这样读改写操作就不是原子的&＃xff0c;操作完之后共享变量的值会和期望的不一致&＃xff0c;举个例子&＃xff1a;如果i&＃61;1,我们进行两次i&＃43;&＃43;操作&＃xff0c;我们期望的结果是3&＃xff0c;但是有可能结果是2。如下图

&＃xff08;例1&＃xff09;

原因是有可能多个处理器同时从各自的缓存中读取变量i&＃xff0c;分别进行加一操作&＃xff0c;然后分别写入系统内存当中。那么想要保证读改写共享变量的操作是原子的&＃xff0c;就必须保证CPU1读改写共享变量的时候&＃xff0c;CPU2不能操作缓存了该共享变量内存地址的缓存。

处理器使用总线锁就是来解决这个问题的。所谓总线锁就是使用处理器提供的一个LOCK&＃xff03;信号&＃xff0c;当一个处理器在总线上输出此信号时&＃xff0c;其他处理器的请求将被阻塞住,那么该处理器可以独占使用共享内存。

3.3 使用缓存锁保证原子性

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

频繁使用的内存会缓存在处理器的L1&＃xff0c;L2和L3高速缓存里&＃xff0c;那么原子操作就可以直接在处理器内部缓存中进行&＃xff0c;并不需要声明总线锁&＃xff0c;在奔腾6和最近的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。所谓“缓存锁定”就是如果缓存在处理器缓存行中内存区域在LOCK操作期间被锁定&＃xff0c;当它执行锁操作回写内存时&＃xff0c;处理器不在总线上声言LOCK&＃xff03;信号&＃xff0c;而是修改内部的内存地址&＃xff0c;并允许它的缓存一致性机制来保证操作的原子性&＃xff0c;因为缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据&＃xff0c;当其他处理器回写已被锁定的缓存行的数据时会起缓存行无效&＃xff0c;在例1中&＃xff0c;当CPU1修改缓存行中的i时使用缓存锁定&＃xff0c;那么CPU2就不能同时缓存了i的缓存行。

但是有两种情况下处理器不会使用缓存锁定。第一种情况是&＃xff1a;当操作的数据不能被缓存在处理器内部&＃xff0c;或操作的数据跨多个缓存行&＃xff08;cache line&＃xff09;&＃xff0c;则处理器会调用总线锁定。第二种情况是&＃xff1a;有些处理器不支持缓存锁定。对于Inter486和奔腾处理器,就算锁定的内存区域在处理器的缓存行中也会调用总线锁定。

以上两个机制我们可以通过Inter处理器提供了很多LOCK前缀的指令来实现。比如位测试和修改指令BTS&＃xff0c;BTR&＃xff0c;BTC&＃xff0c;交换指令XADD&＃xff0c;CMPXCHG和其他一些操作数和逻辑指令&＃xff0c;比如ADD&＃xff08;加&＃xff09;&＃xff0c;OR&＃xff08;或&＃xff09;等&＃xff0c;被这些指令操作的内存区域就会加锁&＃xff0c;导致其他处理器不能同时访问它。

4. JAVA如何实现原子操作

在java中可以通过锁和循环CAS的方式来实现原子操作。

4.1 使用循环CAS实现原子操作

JVM中的CAS操作正是利用了上一节中提到的处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止&＃xff0c;以下代码实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count。

public class Counter {private AtomicInteger atomicI &＃61; new AtomicInteger(0);private int i &＃61; 0;public static void main(String[] args) {final Counter cas &＃61; new Counter();List ts &＃61; new ArrayList(600);long start &＃61; System.currentTimeMillis();for (int j &＃61; 0; j <100; j&＃43;&＃43;) {Thread t &＃61; new Thread(new Runnable() {&＃64;Overridepublic void run() {for (int i &＃61; 0; i <10000; i&＃43;&＃43;) {cas.count();cas.safeCount();}}});ts.add(t);}for (Thread t : ts) {t.start();}// 等待所有线程执行完成for (Thread t : ts) {try {t.join();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(cas.i);System.out.println(cas.atomicI.get());System.out.println(System.currentTimeMillis() - start);}/*** 使用CAS实现线程安全计数器*/private void safeCount() {for (;;) {int i &＃61; atomicI.get();boolean suc &＃61; atomicI.compareAndSet(i, &＃43;&＃43;i);if (suc) {break;}}}/*** 非线程安全计数器*/private void count() {i&＃43;&＃43;;}
}

在java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作&＃xff0c;比如LinkedTransferQueue类的Xfer方法。CAS虽然很高效的解决原子操作&＃xff0c;但是CAS仍然存在三大问题。ABA问题&＃xff0c;循环时间长开销大和只能保证一个共享变量的原子操作。

1. ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化&＃xff0c;如果没有发生变化则更新&＃xff0c;但是如果一个值原来是A&＃xff0c;变成了B&＃xff0c;又变成了A&＃xff0c;那么使用CAS进行检查时会发现它的值没有发生变化&＃xff0c;但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号&＃xff0c;每次变量更新的时候把版本号加一&＃xff0c;那么A&＃xff0d;B&＃xff0d;A 就会变成1A-2B&＃xff0d;3A。
   从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用&＃xff0c;并且当前标志是否等于预期标志&＃xff0c;如果全部相等&＃xff0c;则以原子方式将该引用和该标志的值设置为给定的更新值。
   

   public boolean compareAndSet(V expectedReference,//预期引用V newReference,//更新后的引用int expectedStamp, //预期标志int newStamp) //更新后的标志
   

2. 循环时间长开销大。自旋CAS如果长时间不成功&＃xff0c;会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升&＃xff0c;pause指令有两个作用&＃xff0c;第一它可以延迟流水线执行指令&＃xff08;de-pipeline&＃xff09;,使CPU不会消耗过多的执行资源&＃xff0c;延迟的时间取决于具体实现的版本&＃xff0c;在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突&＃xff08;memory order violation&＃xff09;而引起CPU流水线被清空&＃xff08;CPU pipeline flush&＃xff09;&＃xff0c;从而提高CPU的执行效率。

3. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时&＃xff0c;我们可以使用循环CAS的方式来保证原子操作&＃xff0c;但是对多个共享变量操作时&＃xff0c;循环CAS就无法保证操作的原子性&＃xff0c;这个时候就可以用锁&＃xff0c;或者有一个取巧的办法&＃xff0c;就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i&＃xff1d;2,j&＃61;a&＃xff0c;合并一下ij&＃61;2a&＃xff0c;然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性&＃xff0c;你可以把多个变量放在一个对象里来进行CAS操作。

4.2 使用锁机制实现原子操作

锁机制保证了只有获得锁的线程能够操作锁定的内存区域。JVM内部实现了很多种锁机制&＃xff0c;有偏向锁&＃xff0c;轻量级锁和互斥锁&＃xff0c;有意思的是除了偏向锁&＃xff0c;JVM实现锁的方式都用到的循环CAS&＃xff0c;当一个线程想进入同步块的时候使用循环CAS的方式来获取锁&＃xff0c;当它退出同步块的时候使用循环CAS释放锁。详细说明可以参见文章Java SE1.6中的Synchronized。

5. 参考资料

1. Java SE1.6中的Synchronized
2. Intel 64和IA-32架构软件开发人员手册
3. 深入分析Volatile的实现原理