原子操作的实现原理及CAS

    原子操作就是不可被中断的一个或者一系列操作。

一、处理器如何实现原子操作

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

    1、使用总线加锁

        在多处理器同时对共享变量进行读改写操作时，i=1，对i进行两次自增操作。在没有使用任何同步手段时，我们期望的值时3，但是结果可能是2，因为i++不是原子性的，它的步骤如下图所示。

                                

    处理器使用总线锁就是来解决这个问题的。所谓总线锁就是使用处理器提供的一个Lock#信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。此时就会得到i的值等于3。

    2、使用缓存锁定

        在同一时刻，我们只需保证对某个内存地址的操作时原子性即可，但总线锁定把CPU和内存之间的通信锁住了，开销比较大，目前处理器在某些场合下使用缓存锁定来进行优化

        缓存锁定是指内存区域如果被缓存在处理器的缓存行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不再总线上声言Lock#信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性会阻止同时修改两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。

    但是有两种情况处理器不会使用缓存锁定：

        1、当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时，处理器会使用总线锁定

        2、有些处理器不执行缓存锁定。

二、Java是如何实现原子操作的

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

    1、循环CAS实现原子操作

        Java中的CAS操作正是利用了处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到操作成功为止。

        在CAS中有三个操作数：分别是内存地址（在Java中可以简单理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，当且仅当V符合旧的预期值A时，处理器才会用新值B更新V的值，否则他就不执行更新，但无论是否更新了V的值，都会返回V的旧值。

private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

上述代码就是原子类的自增方法代码。

    valueOffset是原子类的值在内存中的偏移地址，var5是根据原子类对象和原子类的值在内存地址中的偏移地址取到的旧的预期值，var5+var4就是我们想要更新的新值。

    假设上述原子类的值是1，所在的偏移地址为1111

    var1就是原子类的实例对象，var2就是valueOffset（1111）这两者构成CAS的内存地址V，var5就是根据原子类实例对象和变量值的偏移地址取出这个原子类的值（如果是1说明没有其他线程修改这个值，不然就是有其他线程修改了这个值），也就是旧的预期值A，var5+var4所更新的新值B。当var5等于1时，说明旧的预期值符合内存地址V所在数据的值，这时候CPU将内存地址V的值修改为2（var5+var4），退出循环，返回旧值；如果var5不是1，说明其他线程修改了该值，CAS失败，继续尝试，知道成功为止。

private AtomicInteger atomInt = new AtomicInteger(0);
private int i = 0;
public static void main(String[] args) {
    final test3 test = new test3();
    List list = new ArrayList<>(500);
    long ts = System.currentTimeMillis();
    for (int j=0;j<100;j++){
        Thread t = new Thread(){
            @Override
            public void run() {
                for (int m=0;m<1000;m++){
                    test.count();
                    test.safeCount();
                }
            }
        };
        list.add(t);
    }
    for (int k=0;k<100;k++){
        list.get(k).start();
    }
    for (int k=0;k<100;k++){
        try {
            list.get(k).join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println(test.i);
    System.out.println(test.atomInt.get());
    System.out.println(System.currentTimeMillis()-ts);
}
private void count(){
    i++;
}
private void safeCount(){
    for (;;){
        int i = atomInt.get();
        if (atomInt.compareAndSet(i,++i))
            break;
    }
}

    以上代码实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count。

    CAS实现原子操作的三大问题：

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

    2）循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销

    3）只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式保证原子操作，但是对个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁来保证原子操作。

    2、使用锁机制实现原子操作

        锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。