站在巨人肩上操作 CAS（三）：原子操作类的正确使用实战
for (Thread t : ts) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(cas.i);
System.out.println(cas.atomicCount.get());
System.out.println(System.currentTimeMillis() - start);
}
}
CAS 是怎么实现线程的安全呢？语言层面不做处理，我们将其交给硬件—CPU 和内存，利用 CPU 的多处理能力，实现硬件层面的阻塞，再加上 volatile 变量的特性（可见性，有序性）即可实现基于原子操作的线程安全。
CAS 实现原子性操作的三大问题
在 Java 并发包中有一些并发框架也使用了自旋 CAS 的方式来实现原子操作，比如 LinkedTransferQueue 类的 xfer 方法。CAS 虽然很高的解决了原子操作，但是 CAS 仍然存在三大问题。ABA 问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。
ABA 问题
因为 CAS 需要在操作值的时候，检查值有没有发生变化，如果发生变化则更新，但是如果一个值为 A，变成了 B，又变成了 A，那么使用 CAS 进行检查时就会发现它的值没有发生变化，但实际上发生变化了。ABA 问题的解决思路就是使用版本号，在变量前边追加版本号，每次变量更新的时候把版本号加 1，那么 A→B→A 就会变成 1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是 ABA 问题。
从 java1.5 开始，JDK 提供了 AtomicStampedReference、AtomicMarkableReference 来解决 ABA 的问题，通过 compareAndSet 方法检查值是否发生变化以外检查版本号知否发生变化。（AtomicStampedReference 能够得到变化的次数这里下边会介绍到）
循环时间长开销大
自旋 CAS 如果长时间不成功，会给 CPU 带来非常大的执行开销。
只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环 CAS 的方式来保证原子操作，但是对多个共享变量操作时，循环 CAS 就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量 i＝2，j=a，合并一下 ij=2a，然后用 CAS 来操作 ij。从 Java 1.5 开始，JDK 提供了 AtomicReference 类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行 CAS 操作。
Jdk 中相关原子操作类的使用
从 1.5 开始，JDK 的并发包里提供了一些类来支持原子操作，如 AtomicBoolean、AtomicInter。这些原子包装类还提供了简单、性能高效、线程安全有用的工具方法，并且
在并发代码来说是非常关键的。原子变量将发生在单个的变量上，粒度最细的情况。原子变量类有很多种，所以 Atomic 包里一共提供了 13 个类，属于 4 种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性。Atomic 包里的类基本都是通过 Unsafe 实现包装类。
原子更新基本类型
使用原子方式更新基本类型，Atomic 包提供了以下 3 个类。
AtomicBoolean：原子更新布尔值类型
AtomicInteger：原子更新整型
AtomicLong：原子更新长整形
以 AtomicInteger 为例：
public final int addAndGet(int delta)
以原子方式将输入的数值与实例的值相加，并返回结果。
public final boolean compareAndSet(int expect, int update)
如果输入的数值等于预期值，则以原子的方式设置输入的值。
public final int getAndIncrement()
以原子方式将当前值加 1，注意，这里返回的是自增前的值。
public final int getAndSet(int newValue)
以原子方式设置为 newValue 的值，并返回旧值。
接下来我们看一下 getAndIncrement 源码
public final int getAndIncrement()
以原子方式将当前值设置为 1，这里返回的是自增的值。
在 JDK1.8 中 getAndIncrement 是如何实现原子操作的呢？我们分析一下源码，
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
getAndIncrement 方法调用了首先 Unsafe 的 getAndAddInt 方法，获取当前数值，然后循环 compareAndSwapObject 验证 v 和 delta 是否相等如果不相等返回 v，这里意味着 A tmoicInteger 值是否修改过。
接下来我们看 Unsafe 类
//更新变量值为 x，如果当前值为 expected
//o：对象 offset：偏移量 expected：期望值 x：新值
public final native boolean compareAndSwapObject(Object o,long offset,Object expected,Object x);
public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);
public final native boolean compareAndSwapLong(Object o, long offset,long expected,long x);
通过代码，我们发现 Unsafe 只提供了 3 种 CAS 方法：compareAndSwapObject、compareAndSwapInt 和 compareAndSwapLong，再看 AtomicBoolean 源码，发现它是先把 Boolean 转换成整
型，再使用 compareAndSwapInt 进行 CAS，所以原子更新 char、float 和 double 变量也可以用类似
的思路来实现。
原子更新数组
通过原子的方式更新数组里的某个元素，Atomic 包提供了以下四个类。
AtomicIntegerArray：原子更新整型数组里的元素。
AtomicLongArray：原子更新长征信数组里的元素。
AtomicReferenceArray：原子更新引用类型数组里的元素。
以 AtomicIntegerArray 为例，AtomicIntegerArray 的使用实例代码如下
public class AtomicIntegerArrayTest {
static int[] value = new int[] { 1， 2 };
static AtomicIntegerArray ai = new AtomicIntegerArray(value);
public static void main(String[] args) {
ai.getAndSet(0， 3);
System.out.println(ai.get(0));
System.out.println(value[0]);
}
}
输出的结果是 3 和 1，这里要注意的是数组 value 通过构造方法传递进去，然后 AtomicIntegerArray 会将当前数组
复制一份，所以当 AtomicIntegerArray 对内部的数组元素进行修改时，不会影响传入的数组。
原子更新引用类型
原子更新基本类型的 AtomicInteger，只能更新一个变量，则需要使用这个原子引用类型提供的类。
AtomicReference：原子更新引用类型。
AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
AtomicMarkableReference：原子更新带有标记的引用类型，可以以原子更新一个布尔类型的标志位和引用类型。
以 AtomicReference 为例，AtomicReference 的使用示例代码如下
public class AtomicReferenceTest {
public static AtomicReference<user> atomicUserRef = new
AtomicReference<user>();
public static void main(String[] args) {
User user = new User("tim"， 15);
atomicUserRef.set(user);
User updateUser = new User("jack"， 17);
atomicUserRef.compareAndSet(user， updateUser);
System.out.println(atomicUserRef.get().getName());
System.out.println(atomicUserRef.get().getOld());
}
}
代码中首先构建一个 user 对象，然后把 user 对象设置进 AtomicReferenc 中，最后调用
compareAndSet 方法进行原子更新操作，实现原理同 AtomicInteger 里的 compareAndSet 方法。
如果效原子更新某个类的字段需要使用更新字段类
AtomicIntegerFieldUpdater：原子更新整数型字段更新器
AtomicLongFieldUpdater：原子更新长整数字段更新器
AtomicStampedReference：原子更新带有版本号的引用类型。
要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的
时候必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第
二步，更新类的字段（属性）必须使用 public volatile 修饰符。
public class AtomicIntegerFieldUpdaterTest {
// 创建原子更新器，并设置需要更新的对象类和对象的属性
private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class， "old");
public static void main(String[] args) {
// 设置 tim 的年龄是 10 岁
User conan = new User("tim"， 10);
// tim 长了一岁，但是仍然会输出旧的年龄
还未添加个人签名 2021.10.31 加入
还未添加个人简介
评论