我们知道java中volatile关键字，它是一个轻量级的锁并且不支持原子操作
一 基本概念
CAS算法
CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问。
CAS是一种无锁的非阻塞算法(乐观锁)的实现，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。在 java.util.concurrent.atomic 包下面的所有的原子变量类型都实现了这项技术。
需要读写的内存值 V
进行比较的值 A
拟写入的新值 B
当且仅当 V 的值等于 A 时， CAS 通过原子方式用新值 B 来更新 V 的值，否则不会执行任何操作。
演示与分析
多线程情况下的原子性问题
public class CASTest {
public static void main(String[] args) {
DemoRunnable dr = new DemoRunnable();
for (int i = 0; i < 10; i++) {
new Thread(dr).start();
}
}
}
class DemoRunnable implements Runnable {
private volatile int ai ;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程-count:" + (ai++));
}
}
打印结果这里为
子线程-count:0
子线程-count:4
子线程-count:3
子线程-count:2
子线程-count:1
子线程-count:0
子线程-count:5
子线程-count:6
子线程-count:7
子线程-count:8
最中结果不会累加为10
解决方法
在 java.util.concurrent.atomic 包中，提供了很多支持原子操作的类。如：AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference 等。
public class CASTest {
public static void main(String[] args) {
DemoRunnable dr = new DemoRunnable();
for (int i = 0; i < 10; i++) {
new Thread(dr).start();
}
}
}
class DemoRunnable implements Runnable {
private volatile AtomicInteger ai = new AtomicInteger();
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程-count:" + (ai.incrementAndGet()));
}
}
不管是哪个线程最后结束，但是各个线程的累加结果不会重复，它是线程安全的
可能的结果1：
子线程-count:1
子线程-count:4
子线程-count:3
子线程-count:2
子线程-count:5
子线程-count:6
子线程-count:7
子线程-count:8
子线程-count:9
子线程-count:10
可能的结果2
子线程-count:1
子线程-count:6
子线程-count:5
子线程-count:4
子线程-count:3
子线程-count:2
子线程-count:7
子线程-count:8
子线程-count:9
子线程-count:10
源码分析
AtomicInteger源码分析
private volatile int value;
public final int get() {
return value;
}
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final native boolean compareAndSwapInt(Object var1, long var2, int var4,
int var5);
通过声明一个volatile value(内存锁定，同一时刻只有一个线程可以修改内存值)类型的变量，再加上unsafe.compareAndSwapInt的方法，来保证实现线程同步的。
compareAndSet 传入的是执行方法时获取到的 value 属性值，next 为加 1 后的值，compareAndSet所做的为调用 Sun 的 UnSafe 的 compareAndSwapInt 方法来完成，此方法为 native 方法，compareAndSwapInt 基于的是CPU 的 CAS指令来实现的。所以基于 CAS 的操作可认为是无阻塞的，一个线程的失败或挂起不会引起其它线程也失败或挂起。并且由于 CAS 操作是 CPU 原语，所以性能比较好。
CAS的不足
ABA问题
所谓ABA问题就是指在更新前的值是A，但在操作过程中被其他线程更新为B，又更新为 A，这时当前线程认为是可以执行的，其实是发生了不一致现象，如果这种不一致对程序有影响(真正有这种影响的场景很少，除非是在变量操作过程中以此变量为标识位做一些其他的事，比如初始化配置)，在这种情况下就要替修改加上版本号来做唯一的标示，采用初始值+版本号的联合比较法来判断，以此来避免ABA问题。
规避ABA问题可以使用AtomicStampedReference和AtomicMarkableReference这两个类。它们支持在两个变量上执行原子的条件更新。AtomicStampedReference更新一个“对象-引用”二元组，通过在引用上加上“版本号”规避。AtomicMarkableReference则更新一个“对象引用-布尔值”的二元组
CAS这种技术固然很好，但是在复杂的情况下不推荐使用，会带来ABA问题，也可能会因为大量线程的反复重试引起不必要的资源消耗，这样就有点得不偿失了。CAS这项技术适合在一些较为简单的，线程更新不频繁的场景中使用。在简单场景中，作为synchronized的替代品来保护某个变量的原子操作，是个不错的选择。
