什么是CAS机制？

先看下面一段代码：

public class VolatileTest {
    private static int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                            count++;
                    }
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

上述代码线程不安全，结果很可能会小于1000，加上Synchronized同步锁再看一下效果：

public class VolatileTest {
    private static int count = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                            synchronized(VolatileTest.class){
                            count++;
                        }
                    }
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

加上同步锁之后，count自增操作变成了原子性操作，所以最终输出的结果一定是1000。

Synchronized关键字会让没有得到锁资源的线程进入BLOCKED装填，而后在争夺到锁资源后恢复为RUNNABLE状态，这个过程中涉及到操作系统用户模式和内核模式的转换，代价较高。

原子操作类：

所谓原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如：AtomicBoolean,AtomicInteger,AtomicLong等。
我们在代码中引入AtomicInteger类：

public class VolatileTest {
    private static AtomicInteger count = new AtomicInteger();
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                            count.getAndIncrement();
                    }
                }
            }).start();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

结果同样是1000，并且在某些情况下比Synchronized更好。

Atomic操作类的底层正是利用了我们要说的CAS机制。

什么是CAS机制？

CAS是Compare And Swap的缩写，翻译过来就是比较并替换。
CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。
如下：
1，在内存地址V当中，存储着值为10的变量：

2，此时线程1想把变量加1，对于线程1来说，旧的预期值A=10,要修改的新值B=11。

3，在线程1提交更新之前，另一个线程2抢先一步，把变量值改为11

4，线程1开始提交更新，首先进行A和地址V的实际值进行比较，发现A的值不等于V的实际值，提交失败。

5，线程1重新获取内存地址V的当前值，并重新计算要修改的新值，对于线程1来说，A=11,B=12.这个重新尝试的过程被称为自旋。
6，这一次没有其他线程改变地址V的值，线程1进行Compare，发现A的值和地址V的实际值是相同的。

7，线程1进行swap，把地址V的值替换为B,也是就12。

从思想上来说，Synchronized属于悲观锁，悲观的认为程序中的并发情况很严重，所以严防死守；CAS属于乐观锁，乐观的认为并发没那么严重，所以让线程不断的去尝试更新。

Atomic系列类，以及Lock系列类的底层实现都用到了CAS机制。

CAS的缺点：

1，CPU开销较大：在并发量比较大的情况下，如果许多线程反复尝试更新某个变量，却又一直更新不成功，循环往复，会给CPU带来很大的压力；
2，不能保证代码块的原子性：CAS机制所保证的只是一个变量的原子操作，而不能保证整个代码块的原子性，如果要保证多个变量进行原子性的更新，则要使用Synchronized了。
3，ABA问题：这是CAS机制最大的问题。