5、CAS原子操作

 

1 CAS介绍

---

CAS，Compare And Swap，即比较并交换。Doug lea 大神在同步组件中大量使用 CAS 技术鬼斧神工地实现了 Java 多线程的并发操作。整个 AQS 同步组件、Atomic 原子类操作等等都是以 CAS 实现的。可以说 CAS 是整个 JUC 的基石。

CAS 比较交换的过程 CAS(V，A，B)：

V-一个内存地址存放的实际值、A-旧的预期值、B-即将更新的值，当且仅当预期值 A 和内存值 V 相同时，将内存值修改为 B 并返回 true，否则什么都不做，并返回 false。

CAS VS synchronized

• synchronized 是线程获取锁是一种悲观锁策略，即假设每一次执行临界区代码都会产生冲突，所以当前线程获取到锁的之后会阻塞其他线程获取该锁。
• CAS（无锁操作）是一种乐观锁策略，它假设所有线程访问共享资源的时候不会出现冲突，所以出现冲突时就不会阻塞其他线程的操作，而是重试当前操作直到没有冲突为止。

2 解决原子性问题

---

如下代码，目的是启动 10 个线程，每个线程将 a 累加 1000 次，最终得到 a=10000。

public class CASTest {
	public int a = 0;

	public void increase() {
		a++;
	}

	public static void main(String[] args) {
		final CASTest test = new CASTest();
		for (int i = 0; i < 10; i++) {
			new Thread() {
				public void run() {
					for (int j = 0; j < 1000; j++)
						test.increase();
				};
			}.start();
		}

		while (Thread.activeCount() > 1) {
			// 保证前面的线程都执行完
			Thread.yield();
		}
		System.out.println(test.a);
	}
}

结果：每次运行结果都小于 10000。

原因分析：

当线程 1 将 a 加到 2 时，a=2 刷新到主内存；
线程 2 执行增加运算时，到主内存读取 a=2，此时线程 3 也要执行增加运算，也到主内存中读取到 a=2；
线程 2 和线程 3 执行的都是 a=2+1，将 a=3 刷新到主内存。
相当于两次加 1 运算只将 a 增加了 1，也就是说存在执行了多次加 1 运算却只是将 a 增加 1 的情况，所以 10000 次加 1 运算，得到的结果会小于 10000。

原子性问题，解决方案 synchronized 和 CAS。

解决方案一：synchronized 加锁

public synchronized void increase() {
    a++;
}

通过 synchronized 加锁之后，每次只能有一个线程访问 increase()方法，能够保证最终得到 10000。但是 synchronized 加锁是个重量级操作，程序执行效率很低。

解决方案二：CAS

public AtomicInteger a = new AtomicInteger();
public void increase() {
    a.getAndIncrement();
}

利用 CAS，保证 a=a+1 是原子性操作，最终得到结果 10000。

3 CAS 原理

 

 

4 CAS 问题

---

4.1 ABA 问题

CAS 需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是 A，变成了 B，然后又变成了 A，那么在 CAS 检查的时候会认为没有改变，但是实质上它已经发生了改变，这就是 ABA 问题。

解决方案可以沿袭数据库中常用的乐观锁方式，添加一个版本号可以解决。原来的变化路径 A->B->A 就变成了 1A->2B->3A。

在 java 1.5 后的 atomic 包中提供了 AtomicStampedReference 来解决 ABA 问题，解决思路就是这样的。

4.2 自旋时间过长

使用 CAS 时非阻塞同步，也就是说不会将线程挂起，会自旋（无非就是一个死循环）进行下一次尝试，如果自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销。

优化：限制 CAS 自旋的次数，例如 BlockingQueue 的 SynchronousQueue。

4.3 只保证一个共享变量的原子操作

当对一个共享变量执行操作时 CAS 能保证其原子性，如果对多个共享变量进行操作，CAS 就不能保证其原子性。

解决方案：把多个变量整成一个变量

1. 利用对象整合多个共享变量，即一个类中的成员变量就是这几个共享变量，然后将这个对象做 CAS 操作就可以保证其原子性。atomic 中提供了 AtomicReference 来保证引用对象之间的原子性。

2. 利用变量的高低位，如 JDK 读写锁 ReentrantReadWriteLock 的 state，高 16 位用于共享模式 ReadLock，低 16 位用于独占模式 WriteLock。