前言

什么是CAS？

CAS是compare and swap的缩写，即我们所说的比较交换。CAS是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

CAS的带来的问题

①.CAS容易造成ABA问题。

问题描述：线程t1将它的值从A变为B，再从B变为A。同时有线程t2要将值从A变为C。但CAS检查的时候会发现没有改变，但是实质上它已经发生了改变 。可能会造成数据的缺失。

解决方法：CAS还是类似于乐观锁，同数据乐观锁的方式给它加一个版本号或者时间戳，如AtomicStampedReference

②.CAS造成CPU利用率增加

问题描述：多个线程争夺同一个资源时，如果自旋一直不成功，将会一直占用CPU。

解决方法：破坏掉for死循环，当超过一定时间或者一定次数时，return退出。JDK8新增的LongAddr,和ConcurrentHashMap类似的方法。当多个线程竞争时，将粒度变小，将一个变量拆分为多个变量，达到多个线程访问多个资源的效果，最后再调用sum把它合起来。

1) 可以加锁来解决。

2) 封装成对象类解决。

CAS的应用：看AutoInteger的实现源码

其实AutoInteger就是使用了CAS来实现加1，我们知道如果有一个共享变量count=1,开5个线程，每个线程加20次，结果一般来说都会小于100. 

@Test
public void test20() throws InterruptedException {
    for (int i = 1; i <= 5; i++) {
        MyThrend thrend = new MyThrend("thead" + i);
        Thread thread = new Thread(thrend);
        thread.start();
    }
    Thread.sleep(2000);
    System.out.println(MyCount1.count);
}

static class MyThrend implements Runnable {
    private String name;
    MyThrend(String threadName) {
        this.name = threadName;
    }

    @Override
    public void run() {
        for (int i=0;i<20;i++)
        MyCount1.count++;
    }
}

private static class MyCount1 {
    static int count = 0;
}

结果78 

现在修改一个代码，将int变成AtomicInteger

@Test
public void test20() throws InterruptedException {
    for (int i = 1; i <= 5; i++) {
        MyThrend thrend = new MyThrend("thead" + i);
        Thread thread = new Thread(thrend);
        thread.start();
    }
    Thread.sleep(2000);
    System.out.println(MyCount.count.get());
}

static class MyThrend implements Runnable {
    private String name;
    MyThrend(String threadName) {
        this.name = threadName;
    }

    @Override
    public void run() {
        for (int i=0;i<20;i++)
        MyCount.count.getAndIncrement();  //加1方法
    }
}

private static class MyCount {
    static AtomicInteger count = new AtomicInteger(0);
}

每次结果都是100，怎么做到的呢？这里是没有直接加锁的，看源码。

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);  //第一个参数当前对象地址，第二个参数数据偏移量，第三个参数每次指定默认加1
}

public final int getAndAddInt(Object var1, long var2, int var4) {  //这个方法使用的就是CAS,核心在于循环比较内存里面的值和当前值是否相等，如果相等就用新值覆盖
    int var5;   
    do {
        var5 = this.getIntVolatile(var1, var2);  //如果a，b线程同时执行这个方法，a线程拿到值1后cpu执行时间到了挂起，b开始执行，也拿到1，但是没有挂起，接着将值变成了2
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));  //这个时候a线程恢复执行，去比较的时候发现手上的1 和内存里面的值2不等，这个时候他要进行下一个循环，看出来了占用cpu吧
    return var5;
}

AtomicInteger，AtomicLong,AtomicBoolean.....都在java.util.current.atomic包下面，采用了CAS机制来实现加锁。