2.原子变量 CAS算法

前面提到，使用volatile无法保证 变量状态的原子性操作，所谓原子性，就是不可再分

　　如：i++的原子性问题，i++ 的操作实际上分为三个步骤  "读-改-写"

　　(1)保存i的值(一个临时变量中)

　　(2)递增i

　　(3)返回已保存的值

当在并发的条件下执行 i++，

线程1执行 i++，先从主存中 获取 i 的 值（假设初值i=0），还未等 执行i = i + 1，此时线程2进来，也从主存中获取 i 的 值（0）

然后 线程1 执行了 i = i + 1；（i=1） 线程2再执行 i = i + 1（i=1），这种结果是错误的

即使使用 volatile ，保证内存的可见性，也是不管用的，即使在主存中进行修改操作，一样会产生这种错误

 

此时，可以采用 CAS算法 ，CAS算法 是 乐观锁的一种（冲突检测）（hibernate 的乐观锁是 加一个 version 字段，来判断是否发生了并发）

CAS（Compare-And-Swap） 算法 保证数据变量的原子性

CAS 算法是硬件对于并发操作的支持

CAS 包含了三个操作数：

　　* ①内存值 V

　　* ②预估值 A

　　* ③更新值 B

* 当且仅当 V == A 时， V = B; 否则，不会执行任何操作。

过程分析：同样在 并发条件下 执行 i++

　　1、线程1 执行 i++，先从主存中获取 i 的值（V=i=0） （设i=0），此时线程2进来，也从主存中 获取 i 的 值（0）

　　2、然后线程1 执行 getAndIncrement，即比较和替换一起执行，（过程：再从内存中读取一遍i的值（A=i=0），让 A（0） 与 V（0）进行比较，

发现 V==A，此时，B = i+1，将B的值更新到内存中（V = B） ）

　　3、然后 线程2 开始执行 getAndIncrement，即比较和替换一起执行，过程 和 上述类似，不过再从内存读一次值，i的值已经变成了 1 ，即A的值也为1

让A（1）与V（0）进行比较比较，发现 V!=A, 不执行任何操作

注：将 V 与 A 比较的意义在于 判断 要更新的值（V）是否发生了改变，如果没有发生改变，则进行 V 的 更新，否则不做任何操作

再发现 V!=A 后，与 synchronize 不一样的 是，这里不会发生阻塞，不会等当前线程执行完后，再由CPU 分配时间去给线程2去执行，

而是不停的 循环发送请求，紧接着再去尝试，再去更新，这也是 CAS算法 比普通同步锁的做法 效率要高的原因

采用CAS算法之后，当有多个线程访问 内存中的共享资源，一次只会有一个线程成功，其他线程都会失败

 

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:里面频繁的使用到了CAS算法来保证变量状态的原子性操作

　　 AtomicBoolean 、 AtomicInteger 、 AtomicLong 、 AtomicReference

　　 AtomicIntegerArray 、 AtomicLongArray

　　 AtomicMarkableReference

　　 AtomicReferenceArray

　　 AtomicStampedReference

l核心方法：boolean compareAndSet(expectedValue, updateValue)  （也是CAS里面的核心，即比较和替换一起执行（调用CPU的CAS指令））

 

 

/*
 * 一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”
 *           int i = 10;
 *           i = i++; //10
 * 
 *           (1)保存i的值(一个临时变量中)
          (2)递增i
          (3)返回已保存的值
 * 
 * 二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。
 *         1. volatile 保证内存可见性
 *         2. CAS（Compare-And-Swap） 算法保证数据变量的原子性
 *             CAS 算法是硬件对于并发操作的支持
 *             CAS 包含了三个操作数：
 *             ①内存值  V
 *             ②预估值  A
 *             ③更新值  B
 *             当且仅当 V == A 时， V = B; 否则，不会执行任何操作。
 */

public class TestAtomic {
    public static void main(String[] args) {
        
        AtomicDemo ad = new AtomicDemo();
        for(int i = 0;i<10;i++) {
            new Thread(ad).start();
        }
    }
}

class AtomicDemo implements Runnable {
    //创建原子变量
    private AtomicInteger i = new AtomicInteger(0);
    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {

        }
        //查看源码可以发现 循环一直调用compareAndSet(ExceptionValue,UpdateValue)方法，即比较和替换一起执行，
        //并且如果失败了，会不停的去尝试更新(里面使用到CAS算法的)
        System.out.println(i.getAndIncrement());
    }
    
    
}

 

CAS算法本身不会自旋，但是可以自旋CAS来不停地发送请求，如java.util.concurrent.atomic包，这个包里面提供了一组原子类

　　我们来看一段AtomicBoolean中的自旋锁的代码

public final boolean getAndSet(boolean newValue) {
   for (;;) {
       boolean current = get();
       if (compareAndSet(current, newValue))
           return current;
   }
}