线程安全之原子操作
数据一致性问题
有以下一段代码
public class LockDemo {
volatile int i = 0;
public void add() {
i++;
}
public static void main(String[] args) throws InterruptedException {
LockDemo demo = new LockDemo();
for (int k = 0; k < 2; k++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demo.add();
}
System.out.println("线程结束");
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println(demo.i);
}
}
运行结果为，与预期的输出 20000 不一样
线程结束
线程结束
14701
如图，线程 T1 和 T2 都获取到 i = 1，将 i++ 后写入，T1 将 i 赋值为 2 后，T2 又一次赋值也是2，这就产生了数据一致性问题，导致结果并不是预期的 20000.
CAS机制
CAS（compare and swap，比较和交换）属于硬件同步原语，提供了基本内存操作的原子性保证，当赋值时使用 cas，需要输入两个数值，一个旧值A（操作前的值）和一个新值B，在操作期间比较旧值有没有发生变化，如果没有发生变化，才替换为新值。
public void add() {
int current = i;
int value = current + 1;
if (current == i) {
i = value;
}
}
如上图所示，CAS 的作用就是保证比较（if(current == i)）和赋值（i = value）的原子性。
JAVA 的 sun.misc.Unsafe 类提供了 compareAndSwapInt() 和 compareAndSwapLong() 等方法实现CAS。
在 Unsafe 类中 有一个 theUnsafe 实例，它自带一个 getUnsafe()方法
private static final Unsafe theUnsafe;
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}
但是这个方法不能用，所以只能用反射的方式获取，可以使用 compareAndSwapInt() 来实现预期的结果。
compareAndSwapInt 方法有四个参数
compareAndSwapInt(基址(对象的引用), 偏移(对象的属性偏移量), 当前值, 目标值)
使用 CAS 修改代码，如下
public class LockDemo {
volatile int i = 0;
private static Unsafe unsafe;
private static long valueOffset;
static {
try {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
unsafe = (Unsafe) theUnsafe.get(null);
valueOffset = unsafe.objectFieldOffset(LockDemo.class.getDeclaredField("i"));
} catch (NoSuchFieldException | IllegalAccessException e) {
e.printStackTrace();
}
}
public void add() {
int current;
int value;
do {
current = i;
// 也可以直接去内存读取 current = unsafe.getIntVolatile(this,valueOffset);
value = current + 1;
}while (!unsafe.compareAndSwapInt(this, valueOffset,current,value));
}
public static void main(String[] args) throws InterruptedException {
LockDemo demo = new LockDemo();
for (int k = 0; k < 2; k++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
demo.add();
}
System.out.println("线程结束");
}).start();
}
TimeUnit.SECONDS.sleep(2);
System.out.println(demo.i);
}
}
在 j.u.c 包中已经给我们提供了现成的工具类，如：AtomicInteger 和 AtomicLong
以 AtomicInteger 为例，这个类也是使用了 Unsafe 类中的方法，下图是其中的一个方法
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
与手写的代码不同之处在于，因为是 jdk 自己的包，所以可以它可以直接使用 Unsafe.getUnsafe(); 来获得 unsafe 对象
多线程计数工具类
j.u.c 还提供了专门针对多线程优化的计数工具类 DoubleAdder 、 LongAdder 、 DoubleAccumulator 和 LongAccumulator。
这几个工具类在进行计算时，每个线程都有一份自己的值，当需要获取总数时，把每个线程的数相加。所以这些工具适合在频繁更新但读取较少的情况下使用。
CAS 的缺点
- CAS 循环+CAS，自旋的实现让所有线程都处于高频运行，争抢 CPU 的状态，如果长时间操作不成功，会带来很大的 CPU 资源消耗
- 仅针对单个变量进行操作，不能用于多个变量实现原子性操作
- ABA 问题（无法体现出数据的变动）
