CAS原理

CAS

      compare and swap : 比较并交换。

      java.util.concurrent 包借助CAS实现了区别于synchronouse 同步锁的一种 乐观锁。

      concurrent包的实现类图：

     

       由于java的CAS同时具有volaile读和volatile写的内存语义，因此java线程之间的通信有下面四种：

          1.A线程写volatile变量，随后B线程读这个volatile变量。

          2.A线程写volatile变量，随后B线程用CAS更新这个volatile变量。

          3.A线程使用CAS更新volatile变量，随后B线程用CAS更新这个volatile变量。

          4.A线程使用CAS更新volatile变量，随后B线程读这个volatile变量。

        java的CAS会使用现代处理器上提供的高效机器级别原子指令，这些原子指令以原子方式对内存执行读-改-写操作，这是在多处理器中实现同步的关键（从本质上来说，能够支持原子性的读-改-写指令的计算机器，是顺序计算图灵机的异步等价机器，因此任何现代的多核处理器都回去支持某种能对内存执行原子性读-改-写操作的原子指令）。同时，volatile变量的读、写和CAS可以实现线程之间的通信。把这些特性整合在一起就形成了整个concurrent包得以实现的基石。

       仔细分析concurrent包的源码实现，会发现一个通用化的实现模式：

          1.首先声明共享变量volatile类型。

          2.然后使用CAS的原子条件更新来实现线程间同步。 

          3.同时，配合以volatile的读和写 以及 CAS 所具有的volatile读和写的内存语义来实现线程之间的通信。

     AQS、非阻塞数据结构、原子变量类（java.util.concurrent.automic包中的类）都是使用上面的这种模式来实现的，而concurrent包中的高层类又是依赖于这些基础类来实现的。

CAS应用

     CAS有3个操作数，内存值V，旧的预期值A，要更新的新值B。当且仅当旧的预期值A等于内存值V时，将内存值V修改为要更新的新值B，否则什么都不做。

     非阻塞算法（nonblocking algorithms）：一个线程的失败或者挂起不应该影响到其他线程的失败或者挂起的算法。

     现在的CPU提供了特殊指令，可以自动更新共享数据，而且能够检测到其他线程的干扰，儿compareAndSet()就用这些代替了锁定(说白了就是基于指令，而这些指令的实现也是通过CPU锁).

    CPU锁有3种：

            1.处理器自动保证基于内存操作的原子性

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

            2.使用总线锁保证原子性

                如果多个处理器同时对共享变量进行读改写（i++）操作，那么共享变量就会被多个处理器同时操作，那么读改写操作就不是原子性的了，就不能保证操作结束后共享变量的值和期望的值一样。举个例子：如果i=1,我们进行两次i++操作，我们期望的结果是3，但是有可能结果是2。如下图：

               

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

        处理器使用总线锁定来解决这个问题。所谓总线锁定就是使用处理器提供的一个LOCK#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器就可以独占使用共享内存。但是总线锁定把CPU和内存之间的通信锁住了，在锁定期间，其他处理器不能操作其他内存地址的数据。所以，总线锁定开销还是比较大，最近的处理器在某些场合使用缓存锁定来代替总线锁定进行优化。

        3.使用缓存锁定保证原子性

            频繁使用的内存会被缓存在处理器L1、L2 和 L3高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行。所谓缓存锁定就是如果缓存在处理器缓存行中内存区域在LOCK操作期间被锁定，当它执行锁操作回写内存时，处理器不在总线上声明LOCK#信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据，当其它处理器回写已被锁定的缓存行的数据时会视缓存行无效。

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

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

CAS缺点

 CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作

1.  ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

关于ABA问题参考文档: http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedreference.html

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

 

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

 

参考文档：

http://www.blogjava.net/xylz/archive/2010/07/04/325206.html

http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedreference.html

http://www.searchsoa.com.cn/showcontent_69238.htm

http://ifeve.com/atomic-operation/

http://www.infoq.com/cn/articles/java-memory-model-5