(总结)Java多线程_JUC原子类实现

最新推荐文章于 2023-04-01 18:33:22 发布

SteinsJiang

最新推荐文章于 2023-04-01 18:33:22 发布

阅读量218

点赞数

分类专栏： Java基础学习总结文章标签： java 多线程算法

本文链接：https://blog.csdn.net/steinsjiang/article/details/108778187

版权

Java基础学习总结专栏收录该内容

8 篇文章 0 订阅

订阅专栏

CAS+volatile 实现JUC原子类

volatile关键字在以下情况下无法保证原子性：

对变量的写操作不依赖于当前值。
该变量没有包含在具有其他变量的不变式中

因此多线程情况下使用JUC包下的 atomic 中的原子类来确保线程安全；

而原子类的实现依赖于 volatile关键字+CAS操作；

volatile为什么不能保证原子性

以自增操作 i++ 为例：

首先，i++ 操作并不是原子性的，可以分为：①读取i；②cpu进行计算 i+1；③计算结果赋值给 i；
假设有两个线程 A & B 同时进行 i++ 操作；
A 线程读取 i 之后，进行了 i+1 的计算，但是计算结果还没有重新赋值给 i，A 被阻塞，B启动；
这时 B 完成了整个 i++ 操作，新的 i 值被刷新回了内存之中；
由于 A 被阻塞到第二步操作，已经执行完了 i+1 的计算，即使工作内存缓存行失效，它也不会重新读取 i 的值，只会把计算好的 i+1 结果赋值给 i，并刷新回内存，两个线程最后实质上相当于只进行了一次 i++ 操作，所以这时出现线程安全问题；

CAS算法

1.CAS算法涉及到三个操作数：

需要读写的内存值 V(在内存中)；
进行比较的值 A(在寄存器中，是内存中 V 更改之前的副本)；
要写入的新值 B(CPU 使用 A 计算过后的新值)。

当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。

2.java JUC原子类的实现：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

根据定义我们可以看出各属性的作用：

unsafe：获取并操作内存的数据。
valueOffset：存储value在AtomicInteger中的偏移量。
value：存储AtomicInteger的int值，该属性需要借助volatile关键字保证其在线程间是可见的。
接下来，我们查看AtomicInteger的自增函数incrementAndGet()的源码时，发现自增函数底层调用的是unsafe.getAndAddInt()。但是由于JDK本身只有Unsafe.class，只通过class文件中的参数名，并不能很好的了解方法的作用，所以我们通过OpenJDK 8 来查看Unsafe的源码：

// ------------------------- JDK 8 -------------------------
// AtomicInteger 自增方法
public final int incrementAndGet() {
  return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

// Unsafe.class
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;
}

// ------------------------- OpenJDK 8 -------------------------
// Unsafe.java
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;
}

根据OpenJDK 8的源码我们可以看出，getAndAddInt()循环获取给定对象o中的偏移量处的值v，然后判断内存值是否等于v。如果相等则将内存值设置为 v + delta，否则返回false，继续循环进行重试，直到设置成功才能退出循环，并且将旧值返回。整个“比较+更新”操作封装在compareAndSwapInt()中，在JNI里是借助于一个CPU指令完成的，属于原子操作，可以保证多个线程都能够看到同一个变量的修改值。

后续JDK通过CPU的cmpxchg指令，去比较寄存器中的 A 和内存中的值 V。如果相等，就把要写入的新值 B 存入内存中。如果不相等，就将内存值 V 赋值给寄存器中的值 A。然后通过Java代码中的while循环再次调用cmpxchg指令进行重试，直到设置成功为止。

3.CAS虽然很高效，但是它也存在三大问题，这里也简单说一下：

ABA问题。CAS需要在操作值的时候检查内存值是否发生变化，没有发生变化才会更新内存值。但是如果内存值原来是A，后来变成了B，然后又变成了A，那么CAS进行检查时会发现值没有发生变化，但是实际上是有变化的。ABA问题的解决思路就是在变量前面添加版本号，每次变量更新的时候都把版本号加一，这样变化过程就从“A－B－A”变成了“1A－2B－3A”。
JDK从1.5开始提供了AtomicStampedReference类来解决ABA问题，具体操作封装在compareAndSet()中。compareAndSet()首先检查当前引用和当前标志与预期引用和预期标志是否相等，如果都相等，则以原子方式将引用值和标志的值设置为给定的更新值。
循环时间长开销大。CAS操作如果长时间不成功，会导致其一直自旋，给CPU带来非常大的开销。
只能保证一个共享变量的原子操作。对一个共享变量执行操作时，CAS能够保证原子操作，但是对多个共享变量操作时，CAS是无法保证操作的原子性的。
Java从1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。