本次内容主要讲原子操作的概念, 原子操作的实现方式, CAS 的使用, 原理, 3 大问题及其解决方案, 最后还讲到了 JDK 中经常使用到的原子操作类.
1, 什么是原子操作?
所谓原子操作是指不会被线程调度机制打断的操作, 这种操作一旦开始, 就一直运行到结束, 中间不会有任何线程上下文切换. 原子操作可以是一个步骤, 也可以是多个操作步骤, 但是其顺序不可以被打乱, 也不可以被切割而只执行其中的一部分. 我们常用的 i++ 看起来虽然简单, 但这并不是一个原子操作, 具体原理后面单独介绍. 假定有两个操作 A 和 B, 如果从执行 A 的线程来看, 当另一个线程执行 B 时, 要么将 B 全部执行完, 要么完全不执行 B, 那么 A 和 B 对彼此来说是原子的. 将整个操作视作一个整体是原子性的核心特征.
2, 如何实现原子操作?
2.1 锁机制实现原子操作及其问题
实现原子操作可以使用锁. 锁机制满足基本的需求是没有问题的, 但是有的时候我们的需求并非这么简单, 我们需要更有效, 更加灵活的机制. synchronized 关键字是基于阻塞的锁机制, 也就是说当一个线程拥有锁的时候, 访问同一资源的其它线程需要等待, 直到该线程释放锁. 使用 synchronized 关键字存在这样的问题:
(1)如果被阻塞的线程优先级很高很重要怎么办?
(2)如果获得锁的线程一直不释放锁怎么办?
(3)如果有大量的线程来竞争资源, 那 CPU 将会花费大量的时间和资源来处理这些竞争, 同时, 还有可能出现一些例如死锁之类的情况.
使用锁机制是一种比较粗糙, 粒度比较大的机制, 我们可以想象多个线程操作同一个计数器的业务场景, 使用锁机制的话显得太过笨重.
2.2 CAS 机制
实现原子操作还可以使用当前的处理器基本都支持 CAS(Compare And Swap)的指令, CPU 指令集上提供了 CAS 操作相关指令, 实现原子操作可以使用这些指令. 每一个 CAS 操作过程都包含 3 个运算参数: 一个内存地址 V, 一个期望的值 A 和一个新值 B, 操作的时候如果这个地址上存放的值等于这个期望的值 A, 则将地址上的值赋为新值 B, 否则不做任何操作.
2.3 CAS 使用
先来模拟一个多个线程操作同一个计数器的场景, JDK 中提供了 boolean,int 和 long 基本类型对应的原子包装类 AtomicBoolean,AtomicInteger 和 AtomicLong. 我们用 AtomicInteger 演示, 通过 CountDownLatch 进行并发模拟, 如果对 CountDownLatch 用法不了解, 欢迎查看上一篇文章, 有通俗易懂的例子. 先对 AtomicInteger 的主要 API 做一个介绍:
(1)int addAndGet(int delta): 以原子方式将输入的数值与实例中的值 (AtomicInteger 里的 value) 相加, 并返回结果.
(2)boolean compareAndSet(int expect,int update): 如果当前数值等于 expect, 则以原子方式将当前值设置为 update.
(3)int getAndIncrement(): 以原子方式将当前值加 1, 注意, 这里返回的是自增前的值.
(4)int getAndSet(int newValue): 以原子方式设置为 newValue 的值, 并返回旧值.
- import java.util.concurrent.CountDownLatch;
- import java.util.concurrent.atomic.AtomicInteger;
- public class AtomicIntegerDemo {
- static AtomicInteger counter = new AtomicInteger(0);
- static CountDownLatch countDownLatch = new CountDownLatch(20);
- static class CounterThread implements Runnable {
- @Override
- public void run() {
- try {
- countDownLatch.await();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- counter.getAndIncrement();
- }
- }
- public static void main(String[] args) throws InterruptedException {
- for (int i = 0; i <20; i++) {
- Runnable thread = new CounterThread();
- new Thread(thread).start();
- countDownLatch.countDown();
- }
- Thread.sleep(2000); // 保证子线程全部执行完成
- System.out.println("20 个线程并发执行 getAndIncrement()方法后的结果:" + counter.get());
- counter.compareAndSet(20, 18);// 如果 counter 当前数值为 20, 则以原子方式更新为 18
- System.out.println("compareAndSet(20, 18)后的结果:" + counter.get());
- }
- }
程序中模拟了 20 个线程并发对一个计数器进行自增操作, 结果输出为 20, 可以看到这段代码并没有用任何的锁, 也达到了原子操作目的.
2.4 CAS 原理
CAS 的基本思路就是, 如果内存地址 V 上的值和期望的值 A 相等, 则给其赋予新值 B, 否则不做任何事儿. CAS 就是在一个循环里不断的做 CAS 操作, 直到成功为止. CAS 是怎么实现线程的安全呢? 语言层面不做处理, JDK 调用这些指令来完成 CAS 操作, 本质上就是将其交给 CPU 和内存, 利用 CPU 的多处理能力, 实现硬件层面的阻塞, 再加上 volatile 变量的特性即可实现基于原子操作的线程安全. 用一张图来说明.
3,CAS 实现原子操作的三大问题
3.1 ABA 问题
因为 CAS 需要在操作值的时候, 检查值有没有发生变化, 如果没有发生变化则更新, 但是如果一个值原来是 A, 变成了 B, 又变成了 A, 那么使用 CAS 进行检查时会发现它的值没有发生变化, 但是实际上却变化了. 举个通俗易懂的例子, 我的同事老王今年 35 岁了, 还没有女朋友, 我问他有什么要求, 给他介绍一个女朋友. 老王就说了, 只要是没有结婚, 35 岁以下的女的就行. 于是我就给他介绍了一个 28 岁, 刚刚离婚不久的女同志, 他还感谢了我好久, 可能是他现在都还不知道他这个女朋友离过婚. 这就是典型的 ABA 问题, 只关心当前状态, 而不管中间经历了什么. ABA 问题的解决思路就是使用版本号. 给变量追加一个版本号, 每次变量更新的时候把版本号加 1, 那么 A→B→A 就会变成 1A→2B→3A. 就好比老王的要求改成: 35 岁以下, 没有结婚并且离婚次数为 0 的女性, 就不会发生刚刚的事情了.
3.2 循环时间长开销大.
CAS 自旋如果长时间不成功, 会给 CPU 带来非常大的执行开销.
3.3 只能保证一个共享变量的原子操作
当对一个共享变量执行操作时, 我们可以使用循环 CAS 的方式来保证原子操作, 但是对多个共享变量操作时, 循环 CAS 就无法保证操作的原子性, 这个时候就可以用锁. 怎么解决这个问题呢? 从 Java 1.5 开始, JDK 提供了 AtomicReference 类来保证引用对象之间的原子性, 就可以把多个变量放在一个对象里来进行 CAS 操作.
4,JDK 中相关原子操作类
4.1 AtomicReference
AtomicReference, 可以原子更新的对象引用. AtomicReference 有一个 compareAndSet()方法, 它可以将已持有引用与预期引用进行比较, 如果它们相等, 则在 AtomicReference 对象内设置一个新的引用. 看一段代码:
- import java.util.concurrent.atomic.AtomicReference;
- public class AtomicReferenceDemo {
- static AtomicReference<UserInfo> atomicReference;
- public static void main(String[] args) {
- // 原引用
- UserInfo oldUser = new UserInfo("老王", 35);
- atomicReference = new AtomicReference<>(oldUser);
- // 新引用
- UserInfo updateUser = new UserInfo("小宋", 21);
- atomicReference.compareAndSet(oldUser, updateUser);
- System.out.println("使用 compareAndSet()替换原有引用后的结果:" + atomicReference.get());
- System.out.println("原引用:" + oldUser);
- }
- static class UserInfo {
- private String name;
- private int age;
- public UserInfo(String name, int age) {
- this.name = name;
- this.age = age;
- }
- public String getName() {
- return name;
- }
- public int getAge() {
- return age;
- }
- public void setName(String name) {
- this.name = name;
- }
- public void setAge(int age) {
- this.age = age;
- }
- @Override
- public String toString() {
- return "UserInfo{" +
- "name='" + name + '\'' +
- ", age=" + age +
- '}';
- }
- }
- }
从程序输出可以看到, atomicReference 的持有的引用被修改了, 但是原引用对象并没有发生改变.
4.2 AtomicStampedReference
AtomicStampedReference, 利用版本戳的形式记录了每次改变以后的版本号, 这样的话就不会存在 ABA 问题了. AtomicStampedReference 有一个内部类 Pair, 使用 Pair 的 int stamp 作为计数器使用, 看下 Pair 的源码:
- private static class Pair<T> {
- final T reference;
- final int stamp;
- private Pair(T reference, int stamp) {
- this.reference = reference;
- this.stamp = stamp;
- }
- static <T> Pair<T> of(T reference, int stamp) {
- return new Pair<T>(reference, stamp);
- }
- }
还是老王那个例子, 如果使用 AtomicStampedReference 的话, 老王更关心的是介绍的女朋友离过几次婚. 用一段代码来模拟给老王介绍女朋友的场景:
- import java.util.concurrent.atomic.AtomicStampedReference;
- public class AtomicStampedReferenceDemo {
- static AtomicStampedReference<String> asr = new AtomicStampedReference("介绍的女朋友", 0);
- public static void main(String[] args) throws InterruptedException {
- final String oldReference = asr.getReference();// 初始值, 表示介绍的女朋友
- final int oldStamp = asr.getStamp();// 初始版本 0, 表示介绍的女朋友没有离过婚
- Thread thread1 = new Thread(() -> {
- String newReference = oldReference + "离婚 1 次";
- boolean first = asr.compareAndSet(oldReference, newReference,
- oldStamp, oldStamp + 1);
- if (first) {
- System.out.println("介绍的女朋友第一次离婚...");
- }
- boolean second = asr.compareAndSet(newReference, oldReference + "又离婚了",
- oldStamp + 1, oldStamp + 2);
- if (second) {
- System.out.println("介绍的女朋友第二次离婚...");
- }
- }, "介绍的女朋友离婚");
- Thread thread2 = new Thread(() -> {
- String reference = asr.getReference();// 介绍的女朋友最新状态
- // 判断介绍的女朋友最新状态是否符合老王的要求
- boolean flag = asr.compareAndSet(reference, reference + "没有离过婚",
- oldStamp, oldStamp + 1);
- if (flag) {
- System.out.println("老王笑嘻嘻地对我说, 介绍的女朋友符合我的要求");
- } else {
- System.out.println("老王拳头紧握地对我说, 介绍的女朋友居然离过" + asr.getStamp() + "次婚, 不符合我要求!!!!");
- }
- }, "老王相亲");
- thread1.start();
- thread1.join();
- thread2.start();
- thread2.join();
- }
- }
启动 2 个子线程, 分别代表介绍的女朋友多次离婚以及老王相亲的场景. 从程序输出可以看到, 介绍的女朋友不符合老王的要求, 老王为了避免喜当爹, 果断拒绝了.
老王判断的依据是, 介绍的女朋友应该是没有离过婚, stamp 值等于 0 才对. 但是老王仔细一看, stamp 已经是 2, 不符合我的要求, 不能要.
4.3 AtomicMarkableReference
AtomicMarkableReference, 可以原子更新一个布尔类型的标记位和引用类型. 构造方法是 AtomicMarkableReference(V initialRef,booleaninitialMark).AtomicMarkableReference 也有一个内部类 Pair, 使用 Pair 的 boolean mark 来标记状态. 还是老王那个例子, 使用 AtomicStampedReference 可能关心的是离婚次数, AtomicMarkableReference 关心的是有没有离过婚. 用一段代码来模拟:
- import java.util.concurrent.atomic.AtomicMarkableReference;
- public class AtomicMarkableReferenceDemo {
- static AtomicMarkableReference markableReference;
- public static void main(String[] args) throws InterruptedException {
- String girl = "介绍的女朋友";
- markableReference = new AtomicMarkableReference(girl, false);
- Thread t1 = new Thread(() -> {
- markableReference.compareAndSet(girl, girl + "离婚", false, true);
- System.out.println(markableReference.getReference());
- }, "介绍的女朋友离婚了");
- Thread t2 = new Thread(() -> {
- // 老王检查标记, 只关心这个标志位
- boolean marked = markableReference.isMarked();
- if (marked) {
- System.out.println("你给我介绍的女朋友离过婚, 我不要!!");
- } else {
- System.out.println("兄弟, 大兄弟, 亲生兄弟啊!! 这个女朋友我要了");
- }
- }, "老王鉴定介绍的女朋友有没有离过婚");
- t1.start();
- t1.join();
- t2.start();
- t2.join();
- }
- }
程序输出可以看到, 老王还是坚持了自己的原则.
4.4 AtomicIntegerArray
AtomicIntegerArray, 元素可以原子更新的数组. 其常用方法如下:
(1)int addAndGet(int i,int delta): 以原子方式将输入值与数组中索引 i 的元素相加.
(2)boolean compareAndSet(int i,int expect,int update): 如果当前值等于预期值, 则以原子方式将数组位置 i 的元素设置成 update 值.
需要注意的是, 数组 value 通过构造方法传递进去, 然后 AtomicIntegerArray 会将当前数组复制一份, 所以当 AtomicIntegerArray 对内部的数组元素进行修改时, 不会影响传入的数组.
用法比较简单, 看一个例子:
- public class AtomicIntegerArrayDemo {
- static int[] value = new int[]{1, 2};// 原始数组
- static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(value);
- public static void main(String[] args) {
- atomicIntegerArray.getAndSet(0, 3);
- System.out.println("atomicIntegerArray 的第一个元素:" + atomicIntegerArray.get(0));
- System.out.println("原始数组的第一个元素:" + value[0]);// 原数组不会变化
- }
- }
程序输出可以看到, 原始数组并没有受到影响.
顺便看一下 AtomicIntegerArray 的构造方法:
- public AtomicIntegerArray(int[] array) {
- // Visibility guaranteed by final field guarantees
- this.array = array.clone();
- }
5, 结语
文中例子纯属虚构, 便于对知识点的理解, 不掺杂任何其他意思. 下一篇内容中会介绍 Java 的显示锁 Lock 相关知识点, 阅读过程中如发现描述有误, 请指出, 谢谢.
来源: https://www.cnblogs.com/hongshaodian/p/12452110.html