![](https://i-blog.csdnimg.cn/blog_migrate/bce9b34df6089df03ddc69e452451816.jpeg)
个人主页:SueWakeup
系列专栏:学习Java
个性签名:人生乏味啊,我欲令之光怪陆离
![](https://i-blog.csdnimg.cn/blog_migrate/54f4e36a87331ab3759e403012434d53.jpeg)
目录
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 方法的作用是首先检查当前引用是否等于预期引用,并且检查当前标志是否等于预期标志,如果全部相等,则以原子方式将该引用和该标志的值设置为给定的更新值。