簡介

Java 在 JDK 1.5 中提供了 java.util.concurrent.atomic 包，這個包中的原子操作類提供了一種用法簡單、效能高效、執行緒安全地更新一個變數的方式。主要提供了四種類型的原子更新方式，分別是原子更新基本型別、原子更新陣列、原子更新引用和原子更新屬性。

Atomic 類基本都是使用 Unsafe 來保證執行緒安全。

public final class Unsafe {
    ...

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

    ...
}
 

JDK 1.8 中，Doug Lea 又在 atomic 包中新增了 LongAccumulator 等並行累加器，提供了更高效的無鎖解決方案。

原子更新基本資料型別

• AtomicBoolean：原子更新布林型別
• AtomicInteger：原子更新整型
• AtomicLong：原子更新長整型

public class AtomicIntegerTest {

    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    private static AtomicInteger atomicInteger = new AtomicInteger(1);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                try {
                    countDownLatch.await();
                    // 以原子方式將當前值加 1，並返回之前的值
                    System.out.print(atomicInteger.getAndIncrement() + " ");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
        // 執行緒同時進行爭搶操作
        countDownLatch.countDown();
        Thread.sleep(2000);
        System.out.println();
        // 以原子方式將輸入的數值與例項中的值相加，並返回結果。
        System.out.println(atomicInteger.addAndGet(10));
        // CAS 操作
        atomicInteger.compareAndSet(21, 30);
        System.out.println(atomicInteger.get());
    }
}
 

原子更新陣列

• AtomicIntegerArray：原子更新整型數組裡的元素
• AtomicLongArray：原子更新長整型數組裡的元素
• AtomicReferenceArray：原子更新引用型別數組裡的元素

public class AtomicReferenceArrayTest {

    // AtomicReferenceArray 會將當前陣列（VALUE）複製一份，所以當 AtomicReferenceArray 對內部的陣列元素進行修改時，不會影響傳入的陣列。
    private static Stu[] VALUE = new Stu[]{new Stu(System.currentTimeMillis(), "張三"),new Stu(System.currentTimeMillis(), "李四")};

    private static AtomicReferenceArray<Stu> REFERENCE_ARRAY = new AtomicReferenceArray<>(VALUE);

    public static void main(String[] args) {
        // 修改指定位置元素的值
        REFERENCE_ARRAY.getAndSet(0, new Stu(System.currentTimeMillis(), "王五"));
        System.out.println(REFERENCE_ARRAY.get(0));
        System.out.println(VALUE[0]);
    }
}
 

原子更新引用

• AtomicReference：原子更新引用型別
• AtomicMarkableReference：原子更新帶有標記位的引用型別
• AtomicStampedReference：原子更新帶有版本號的引用型別

public class AtomicStampedReferenceTest {

    private static Stu stu = new Stu(System.currentTimeMillis(), "張三");
    /**
     * 更新物件的時候帶一個版本號，可以防止 CAS 中 ABA 問題。原理在於 compare 的時候不僅比較原來的值，還比較版本號。同理更新的時候也需要更新版本號
     */
    private static AtomicStampedReference<Stu> stampedReference = new AtomicStampedReference(stu, 1);

    public static void main(String[] args) {
        System.out.println(stampedReference.getReference());
        Stu newStu = new Stu(System.currentTimeMillis(), "李四");
        int stamp = stampedReference.getStamp();
        stampedReference.compareAndSet(stu, newStu, stamp, stamp++);
        System.out.println(stampedReference.getReference());
    }
}

原子更新屬性

• AtomicIntegerFieldUpdater：原子更新整型的欄位的更新器
• AtomicLongFieldUpdater：原子更新長整型欄位的更新器
• AtomicReferenceFieldUpdater：原子更新引用型別裡的欄位

public class AtomicReferenceFieldUpdaterTest {

    // 建立原子更新器，並設定需要更新的物件類和物件的屬性
    private static AtomicReferenceFieldUpdater<Stu, String> atomicUserFieldRef = AtomicReferenceFieldUpdater.newUpdater(Stu.class, String.class, "name");

    public static void main(String[] args) {
        Stu stu = new Stu(System.currentTimeMillis(), "張三");
        atomicUserFieldRef.set(stu, "李四");
        System.out.println(stu.getName());
    }
}

需要注意的是，更新類的屬性必須使用 public volatile 修飾符。以下是 AtomicReferenceFieldUpdater 的原始碼內容：

            if (vclass.isPrimitive())
                throw new IllegalArgumentException("Must be reference type");

            if (!Modifier.isVolatile(modifiers))
                throw new IllegalArgumentException("Must be volatile type");

1.8 的並行累加器

AtomicLong 維護一個變數 value，通過 CAS 提供非阻塞的原子性操作。不足的是，CAS 失敗後需要通過無限迴圈的自旋鎖不斷嘗試，這在高併發N多執行緒下，將大大浪費 CPU 資源。

那麼如果把一個變數分解為多個變數，讓同樣多的執行緒去競爭多個資源那麼效能問題不就解決了？是的，JDK8提供的 LongAdder 就是這個思路。

LongAdder 的核心思想是分段，它繼承自 Striped64，Striped64 有兩個引數 long base 和 Cell[] cells ,接著來看看 LongAddr 的核心程式碼：

public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
        //想要add一個元素的時候，先看一下 cells 陣列是否為空，如果是空的就嘗試去看能不能直接加到 base上面，如果執行緒競爭很小就加到 base上面了，函式結束
        //如果 cells 是空的，並且競爭很大，cas 失敗，就進入if塊內，建立 cells
        //如果不是空的就進入到 cell 陣列中看能加到哪個上面去
        if ((as = cells) != null || !casBase(b = base, b + x)) {
            boolean uncontended = true;
            //如果 cells 是空的，就執行增加操作
            if (as == null || (m = as.length - 1) < 0 || (a = as[getProbe() & m]) == null || !(uncontended = a.cas(v = a.value, v + x)))
                longAccumulate(x, null, uncontended);
        }
    }

所以想要得到累加的結果，只能呼叫 LongAdder 的 sum() 方法，即 base + cell[] 陣列元素的和。需要注意的是，在計算總和時發生的併發更新可能不會被合併