个人主页：SueWakeup
系列专栏：学习Java
个性签名：人生乏味啊，我欲令之光怪陆离
目录
Java 中的原子操作类(基于 CAS 的 AtomicInteger)
注：手机端浏览本文章可能会出现 “目录”无法有效展示的情况，请谅解，点击侧栏目录进行跳转
前言
在高并发的业务场景下，线程安全可以通过 synchronized 或 Lock 来保证同步，从而达到线程安全的目的。但是， synchronized 或 Lock 都是基于互斥锁的思想实现，加锁和释放锁的过程中都会带来性能损耗问题。
除了 synchronized 或 Lock 以外，还可以通过 JUC（java.util.concurrent.xxx）提供的 CAS 机制实现无锁的解决方案，它是基于乐观锁的思想方案，实现非阻塞的同步方式，从而保证线程安全。
悲观锁和乐观锁
- 悲观锁
- 在持有数据的时候将 资源 或 数据 加锁，认为数据很可能会被其他人所修改（线程冲突）
- 适用于写多读少的场景，避免频繁失败和重试影响性能
- 乐观锁
- 程序不加锁，认为资源和数据不会被别人所修改（线程冲突），但在进行写入操作的时候会判断当前数据是否被修改过，一旦有冲突发生，通常采用一种称为 CAS 的技术保证线程执行的安全性
- 适用于读多写少的场景，避免加锁影响性能
什么是 CAS ?
- CAS 全称 “比较并交换”（Compare And Swap）。是一种原子操作
- 现代 CPU 广泛支持的一种对内存中的共享数据进行操作的特殊指令。进行读写操作时， CPU 会比较内存中某个值是否和预期的值相同，如果相同则将这个值更新为新值，不相同则不做更新
- 无锁的线程同步解决方案，基于 “乐观锁” 思想的操作，保证多线程并发中保障共享资源的原子操作，相对于 synchronized 或 Lock 来说，是一种轻量级的实现方案
- 使用案例：
- Java 的核心类库中 AtomicInteger、ConcurrentHashMap 都是基于 CAS 机制实现原子操作（Java 中的 CAS 机制是通过 Unsafe 类提供的 compareAndSwapXXX() 等 CAS 方法实现，底层通过 CPU 指令 cmpxchg 实现）
什么是原子操作？
原子操作是指不能被线程调度打断的操作。通常是一系列操作，该系列操作从执行开始到执行结束期间不会发生线程切换（原子操作不能被中断）。
CAS 执行流程
假设内存中存在一个变量 i，它在内存中对应的值是 A（第一次读取） ，此时经过业务计算处理后，结算结果为新值 B，在更新之前会再去读 i 现在的值 C。如果 A 和 C 相同，代表业务计算处理的过程中 i 的值并没有发生变化，才会把 i 更新（交换）为新值 B。如果不相同，那说明在业务计算时，i 的值发生了变化，则不进行更新操作。最后 CPU 会将旧的数值返回。
总结：要更新的值是否等于旧值，如果等于，将该值设置为新值；如果不等于，将旧数值返回
Java 中的原子操作类(基于 CAS 的 AtomicInteger)
- Java 无法控制线程的切换，所以 Java 中 CAS 操作采用 native 方法，底层采用 C 或 C++ 实现
AtomicInteger 是 java.util.concurrent.atomic 包下的一个子类，该包下还有 AtomicBoolean ,AtomicLong,AtomicLongArray,AtomicReference 等原子类，主要用于在高并发环境下，保证线程安全。
AtomicInteger 常用方法
// AtomicInteger 常用方法
public final int get(); // 获取当前值
public final int getAndSet(int newValue); // 获取当前的值，并设置新的值
public final int getAndIncrement(); // 获取当前的值，并自增 1
public final int getAndDecrement(); // 获取当前的值，并自减 1
public final int getAndAdd(int delta); // 获取当前的值，并自增指定值AtomicInteger 核心源码
public class AtomicInteger extends Number implements java.io.Serializable {
//底层访问对象
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
try {
//基于 Unsafe 对象获取 value 字段相对当前对象的“起始地址”的偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
// 获取当前的值
public AtomicInteger(int initialValue) {
value = initialValue;
}
/* 获取当前的值，并自增 1
* 1.this:当前的实例
* 2.valueOffset:value实例变量的偏移量
* 3.delta:自增 1
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/* 获取当前的值，并自增指定值
* 1.this:当前的实例
* 2.valueOffset:value实例变量的偏移量
* 3.delta:自增指定值
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
}Unsafe
在 AtomicInteger 核心源码中，可以看到 CAS 机制是通过 Unsafe 类实现。
sum.misc.Unsafe 是 JDK 提供的一个底层工具类。它提供内存操作、CAS、对象操作等 “不安全” 的功能，来让 JDK 能够使用 Java 代码来实现原本需要使用 native 本地方法才可以实现的功能。由于，该类不应该在 JDK 核心类库之外使用，所以被命名为 Unsafe（不安全）
Unsafe 实现 CAS 的工作原理
AtomicInteger 类
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}Unsafe 类
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}首先读取当前对象 var1 在主内存中的值，并保存到 var5 中，然后通过循环，判断当前对象在主内存中的值是否等于 var5，如果相同，就自增（交换 var5 与 var5 + var4 两个值），否则继续循环，重新获取 var 值。
在上述逻辑中核心方法是 compareAndSwapInt()方法，它是一个 native 方法，这个方法编译后的 CPU 指令是 cmpxchg，该指令连续执行，不会被打断，所以可以保证原子性。
在 getAndAddInt()方法中通过 do...while 循环操作实现自旋锁：当预期值和主内存中的值不等时，就重新获取主内存中的值。
CAS 的缺点
- 循环时间长，开销大
- 在 Unsafe 的实现中使用了自旋锁的机制。在该环境如果 CAS 操作失败，就需要循环进行 CAS 操作（do...while 循环同时读取最新的期望值），如果长时间都不成功的话，那么会造成 CPU 极大的开销
- 只能保证一个共享变量的原子操作
- 在最初的实例中，可以看出是针对一个共享变量使用了 CAS 机制，可以保证原子性操作。但如果存在多个共享变量，或一整个代码块的逻辑需要保证线程安全，CAS 就无法保证原子性操作
- 此时，需要考虑采用加锁方式（悲观锁）保证原子性
- ABA 问题
- 线程 P1 在共享变量中读到值 A
- 线程 P1 被抢占，线程 P2 开始执行
- 线程 P2 把共享变量里的值从 A 改成了 B，再改回到 A
- 线程 P2 被抢占，线程 P1 开始执行
- 线程 P1 回来看到共享变量里的值没有被改变，继续执行
可以通过 JDK 的 Atomic 包中的 AtomicStampedReference 类来解决 ABA问题：使用 compareAndSet 方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
833
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
