Java并发工具类原子类

Posted 2021-03-07 myworld7

前言

为保证计数器中count=+1的原子性，我们在前面使用的都是synchronized互斥锁方案，加锁独占访问的方式未免太过霸道，于是我们来介绍另一种解决原子性问题的无锁方案：原子变量。在正式介绍原子变量之前，我们先来总结下锁的不足，然后深入介绍原子变量。

锁的劣势

通过对共享变量加锁，使得获取到锁的线程可以采用独占方式来访问共享变量，并且对变量的修改对随后获取这个锁的其他线程都是可见的（Happens-Before规则）。

当多个线程同时请求锁时，对于没有获取到锁的线程将有可能被挂起并且在稍后才恢复运行（有时会选择自旋等待）。当线程恢复执行时，必须等待其他线程执行完它们的时间片后，才能被调度执行。我们需要知道，在挂起和恢复线程等过程中会存在着很大的开销，并且通常存在着较长时间的中断。

加锁方案在竞争激烈的情况下，其性能会由于上下文切换的开销和调度延迟而降低。而如果锁的持有时间非常短，那么在不恰当的时间请求锁时，线程休眠的代价将会不太划算。

加锁还存在一些缺点：

• 当一个线程正在等待锁时，它不能做任何其他事情。
• 如果一个线程在持有锁的情况下被延迟执行（例如发生了缺页错误、调度延迟、或者其他情况），那么所有需要这个锁的线程都无法执行下去。
• 如果被阻塞的线程优先级较高，而持有锁的线程优先级较低，那么将会导致优先级反转问题。
  即使高优先级的线程可以抢先执行，但仍然需要等待锁被释放，从而导致它的优先级会降到低优先级线程的级别。
• 如果持有锁的线程被永久地阻塞（例如优于出现了无限循环，死锁，活锁或者其他活跃性问题），所有等待这个锁的线程就永远无法执行下去。

与锁相比，valatile变量是一种轻量级地同步机制，因为在使用这些变量时不会发生上下文切换或线程调度等操作。与锁一样虽然提供了可见性保证，但是volatile变量不能用于构建原子的复合操作。好消息是，下面我们将介绍的原子变量不仅提供了与volatile变量相同的内存语义，还支持原子的更新操作，比基于锁的方案有着更高的可伸缩性。

原子变量的实现原理: 硬件对并发的支持

硬件对并发的支持

独占锁是一项悲观技术，对于细粒度操作（例如计数器），还有另外一种更高效的方法，也是乐观方法，通过这种方法也可以在不受其他线程干扰的情况下完成更新操作。这种方法通过借助冲突检查机制来判断在更新过程中是否存在来自其他线程的干扰，如果存在，这个操作将失败，并且可以重新尝试（也可以不尝试）。

这种方法也就是处理器中提供的一些特殊指令（这些特殊指令本身可以保证原子性）。这些指令用于管理对共享数据的并发访问。
在早期的处理器中支持原子的测试并设置（Test-and-Set），获取并递增（Fetch-and-Increment）以及交换（Swap）等指令，这些指令足以实现各种互斥体，而这些互斥体又可以实现一些更加复杂的并发对象。
现在几乎所有的现代处理器都包含了某种形式的原子读-改-写指令，例如比较并交换（CAS，Compare-and-Swap）或者关联加载/条件存储（Load-Linked/Store-Conditional）。

操作系统和JVM使用这些指令来实现锁和并发的数据结构，在Java 5.0之前，Java类中还不能直接使用这些指令。

原子类由这些特殊的指令实现，所有其性能会比较高。

比较并交换

在大多数处理架构中，对上述方法的实现是实现一个比较并交换（CAS）之指令。（在其他处理器中，采用一对指令来实现相同的功能：关联加载与条件存储。）

CAS包含了3个操作数：需要读写的内存地址V，进行比较的值A和拟写入的新值B。

当且仅当V中的值等于A时，CAS才会通过原子方式用新值B来更新V中的值，否则不会执行任何操作。无论位置V的值是否等于A，都将返回V原有的值。

CAS是一项乐观的技术，它希望能成功地执行更新操作，并且如果有另一个线程在最近一次检查后更新了该变量，那么CAS能检测到这个错误。

以下的SimulatedCAS模拟代码说明CAS的语义，用来理解CAS的工作原理(^{[2]})。

public class SimulatedCAS {
    private int value;

    public synchronized int get() {
        return value;
    }

    public synchronized int compareAndSwap(int expectedValue, int newValue) {
        // 读取目前的value值
        int oldValue = value;
        // 比较目前value值是否等于期望值
        if (oldValue == expectedValue)
            value = newValue; // 如果相等，则更新value的值
        return oldValue; // 返回写入之前的值
    }

    public synchronized boolean compareAndSet(int expectedValue, int newValue) {
        return (expectedValue == compareAndSwap(expectedValue, newValue));
    }
}

当多个线程尝试使用CAS同时更新一个变量时，只有其中一个线程能够更新变量的值，而其他线程都将失败。但是，与获取锁实现的线程不一样，这里失败的线程并不会被挂起，而是被告知在这次竞争中失败，并可以再次尝试（或者选择不尝试，做一些其他恢复操作等）。这种方式的灵活性大大减少与锁相关的活跃性风险。

CAS的典型使用模式：首先从V中读取值A，并根据A计算新值B，然后在通过CAS以原子方式将V中的值由A变为B，前提是这个期间没有其他线程将V的值修改为其他值。
由于CAS能检测到来自其他线程的干扰，因此即使不用锁也能够实现原子的读-改-写操作。

非阻塞的计数器

下面我们使用CAS来实现一个线程安全的计数器。递增操作采用标准方式：读取旧值，根据它计算新值，并使用CAS来设置这个新值。如果CAS失败，那么该操作将立即重试。反复的重试也称为自旋。通常，反复地重试是一种合理的策略，但是在一些竞争激烈的情况下，最好的方式实在重试之前先等待一段时间或者回退，从而避免造成活锁问题。

下面基于“CAS+自旋”实现计数器(^{[2]})：

public class CasCounter {
    private SimulatedCAS value;

    public int getValue() {
        return value.get();
    }

    public int increment() {
        int v;
        do {
            v = value.get(); // 获取旧值
        } while (v != value.compareAndSwap(v, v + 1)); // 自旋尝试
        return v + 1;
    }
}

CasCounter不会阻塞，但是如果其他线程同时更新计数器，那么会多次执行重试操作。

这样看来，似乎基于CAS的计数器比基于锁的计数器性能要差一点，因为它需要执行更多的操作和更复杂的控制流。然而实际情况却并非如此。虽然Java语言的锁定语法简洁，但是JVM和操作在管理锁时需要完成的工作却并不简单，即使用锁简单，锁背后要做的工作却复杂。
在实现锁定时需要遍历JVM中一条非常复杂的代码路径，并可能导致操作系统级的锁定、线程挂起以及上下文切换等操作。并且，在最好情况下（获取无竞争的锁），在锁定时至少需要一次CAS，因此虽然在使用锁时没有用到CAS，但实际上也无法节约任何执行开销，也就是说会比CAS执行更多的操作。
在程序内部执行CAS时是不需要执行JVM代码、系统调用或者线程调度操作。在应用级别看起来越长的代码路径，如果加上JVM和操作系统中的代码调用，那么事实上却变得更短。

而CAS的主要缺点在于：它将使调用者来处理竞争问题（通过重试、回退和放弃），而在锁中能自动处理竞争问题（线程在获取锁之间将一直被阻塞）。
CAS的性能也会随着处理器数量的不同、体系架构的不同甚至处理器版本的不同而产生变化。

ABA问题

ABA问题是指：如果V的值首先由A变成了B，再由B变成了A，虽然V中的值A好像没有变，但是在某些算法中，A的属性却是变了。对于保护的变量是数值类型是不需要关心ABA问题，但是如果是对象，就需要注意。

一个相对简单的解决办法是：不是更新某个引用的值，而是更新两个值，包括一个引用和一个版本号。即使这个值由A变成了B，然后又变成了A，版本号也将是不同的。AtomicStampedReference和AtomicMarkableReference支持在两个变量上执行原子的条件更新。
AtomicStampedReference将更新一个“对象-引用”二元组，通过在引用上加上“版本号”，从而避免了ABA问题。
同样，AtomicMarkableReference将更新一个“对象引用-布尔值”二元组。

JVM对CAS的支持

在Java 5.0之前，如果不编写明确的代码，那么就无法执行CAS。在Java 5.0中引入了底层的支持，在int、long和对象的引用等类型上都公开了CAS操作，并且JVM把它们编译为底层硬件提供的最有效方法。在支持CAS的平台上，运行时把它们编译为相应的（多条）机器指令。在最坏情况下，如果不支持CAS指令，那么JVM将使用自旋锁。

在原子变量类（例如java.util.concurrent.atomic中的AtomicXxx）中使用了这些底层的JVM支持为数字类型和引用类型提供的一种高效的CAS操作，而在java.util.concurrent中的大多数类在实现时则直接或间接地使用了这些原子变量类。

原子类概览

Java JDK并发包中提供的原子类很丰富，可以分为五个类别：标量类（基本数据类）、对象引用类、数组类、对象属性更新器类和累加器类。

Java提供的原子类里面CAS一般被实现为compareAndSet()，compareAndSet()的语义和CAS指令语义的差别仅仅是返回值的不同，compareAndSet()里面如果更新成功，则会返回true，否则返回false。

do {
    // 获取当前值
    oldV = xxxx；
    // 根据当前值计算新值
    newV = ...oldV...
}while(!compareAndSet(oldV,newV);

原子标量类（原子基本数据类）

相关实现类有AtomicBoolean、AtomicInteger和AtomicLong，提供的方法主如下：

getAndIncrement() // 原子化 i++
getAndDecrement() // 原子化的 i--
incrementAndGet() // 原子化的 ++i
decrementAndGet() // 原子化的 --i
// 当前值 +=delta，返回 += 前的值
getAndAdd(delta)
// 当前值 +=delta，返回 += 后的值
addAndGet(delta)
//CAS 操作，返回是否成功
compareAndSet(expect, update)
// 以下四个方法
// 新值可以通过传入 func 函数来计算
getAndUpdate(func)
updateAndGet(func)
getAndAccumulate(x,func)
accumulateAndGet(x,func)

原子对象引用类

相关实现有AtomicReference、AtomicStampedReference和AtomicMarkableReference，利用它们可以实现对象引用的原子化更新。

AtomicReference提供的方法和原子化的基本数据类型差不多。不过，需要注意，对象引用的更新需要重点关注ABA问题，正如前面提过，AtomicStampedReference和AtomicMarkableReference这两个原子类可以解决ABA问题。　

AtomicStampedReference实现的CAS方法增加的版本号参数，方法签名如下：

boolean compareAndSet(
    V expectedReference,
    V newReference,
    int expectedStamp,
    int newStamp)

AtomicMarkableReference的实现机制更简单，将版本号简化成了一个Boolean值，方法签名如下：

boolean compareAndSet(
    V expectedReference,
    V newReference,
    boolean expectedMark,
    boolean newMark)

原子数组类

相关实现有AtomicIntegerArray、AtomicLongArray和AtomicReferenceArray，利用这些原子类，我们可以原子化地更新数组中的每一个元素。

这些类提供的方法和原子化基本数据类型的区别仅仅是：每个方法多了一个数组的索引参数。

原子对象属性更新器类

相关实现有AtomicIntegerFieldUpdater、AtomicLongFieldUpdater和AtomicReferenceFieldUpdater。利用它们可以原子化地更新对象的属性，这三个方法都是利用反射机制实现的，创建更新器的方法如下：

public static <U> AtomicXXXFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName)

需要注意，对象属性必须是volatile类型的，只有这样才能保证可见性；如果对象属性不是volatile类型的，newUpdater()方法会抛出IllegalArgumentException这个运行时异常。

newUpdater()方法的参数中只有类的信息没有对象的引用，而更新对象的属性，需要对象的引用，那么这个参数是再哪里传入的呢？
是在原子类操作的方法参数中传入的。例如，compareAndSet()这个原子操作，相比原子化的基本数据类型参数多了一个对象引用obj。

boolean compareAndSet(
    T obj,
    int expect,
    int update)

原子化对象属性更新器相关方法，相比原子类的基本数据类型仅仅是多了对象引用参数。

原子累加器类

DoubleAccumulator、DoubleAdder、LongAccumulator和LongAdder，这四个类仅仅用来执行累加计数操作，相比原子化的基本数据类型，速度更快，但是不支持compareAndSet()方法。

在实际情况中，如果仅需一个计数器或者序列生成器，那么可以直接使用AtomicInteger或者AtomicLong，它们能提供原子的递增方法以及其他算术方法。

小结

原子变量比锁的粒度更细，量级更轻。原子变量类也相当于一种泛化的volatile变量。原子变量较于锁来说，在性能和降低活跃性方面都表现很好，但是原子变量是将发生竞争的范围缩小到单个变量上，当需要解决多个共享变量的原子性问题，还是建议使用锁。

参考:
[1] 极客时间专栏王宝令《Java并发编程实战》
[2] Brian Goetz.Tim Peierls. et al.Java并发编程实战[M].北京:机械工业出版社,2016