前言

激烈的鎖競爭，會造成執行緒阻塞掛起，導致系統的上下文切換，增加系統的效能開銷。那有沒有不阻塞執行緒，且保證執行緒安全的機制呢？——樂觀鎖。

樂觀鎖是什麼？

操作共享資源時，總是很樂觀，認為自己可以成功。在操作失敗時（資源被其他執行緒佔用），並不會掛起阻塞，而僅僅是返回，並且失敗的執行緒可以重試。

優點：

• 不會死鎖
• 不會飢餓
• 不會因競爭造成系統開銷

樂觀鎖的實現

CAS 原子操作

CAS。在 java.util.concurrent.atomic 中的類都是基於 CAS 實現的。

以 AtomicLong 為例，一段測試程式碼：

@Test
public void testCAS() {
    AtomicLong atomicLong = new AtomicLong();
    atomicLong.incrementAndGet();
}
 

java.util.concurrent.atomic.AtomicLong#incrementAndGet 的實現方法是：

public final long incrementAndGet() {
    return U.getAndAddLong(this, VALUE, 1L) + 1L;
}

其中 U 是一個 Unsafe 例項。

private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();

本文使用的原始碼是 JDK 11，其 getAndAddLong 原始碼為：

@HotSpotIntrinsicCandidate
public final long getAndAddLong(Object o, long offset, long delta) {
    long v;
    do {
        v = getLongVolatile(o, offset);
    } while (!weakCompareAndSetLong(o, offset, v, v + delta));
    return v;
}

可以看到裡面是一個 while 迴圈，如果不成功就一直迴圈，是一個樂觀鎖，堅信自己能成功，一直 CAS 直到成功。最終呼叫了 native 方法：

@HotSpotIntrinsicCandidate
public final native boolean compareAndSetLong(Object o, long offset,
                                                long expected,
                                                long x);

處理器實現原子操作

從上面可以看到，CAS 是呼叫處理器底層的指令來實現原子操作，那麼處理器底層是如何實現原子操作的呢？

處理器的處理速度>>處理器與實體記憶體的通訊速度，所以在處理器內部有 L1、L2 和 L3 的快取記憶體，可以加快讀取的速度。

單核處理器能夠儲存記憶體操作是原子性的，當一個執行緒讀取一個位元組，所以程序和執行緒看到的都是同一個快取裡的位元組。但是多核處理器裡，每個處理器都維護了一塊位元組的記憶體，每個核心都維護了一個位元組的快取，多執行緒併發會存在快取不一致的問題。

那處理器如何保證記憶體操作的原子性呢？

• 匯流排鎖定：當處理器要操作共享變數時，會在總線上發出 Lock 訊號，其他處理器就不能操作這個共享變量了。
• 快取鎖定：某個處理器對快取中的共享變數操作後，就通知其他處理器重新讀取該共享資源。

LongAdder vs AtomicLong

本文分析的 AtomicLong 原始碼，其實是在迴圈不斷嘗試 CAS 操作，如果長時間不成功，就會給 CPU 帶來很大開銷。JDK 1.8 中新增了原子類 LongAdder，能夠更好應用於高併發場景。

LongAdder 的原理就是降低操作共享變數的併發數，也就是將對單一共享變數的操作壓力分散到多個變數值上，將競爭的每個寫執行緒的 value 值分散到一個數組中，不同執行緒會命中到陣列的不同槽中，各個執行緒只對自己槽中的 value 值進行 CAS 操作，最後在讀取值的時候會將原子操作的共享變數與各個分散在陣列的 value 值相加，返回一個近似準確的數值。

LongAdder 內部由一個base變數和一個 cell[] 陣列組成。當只有一個寫執行緒，沒有競爭的情況下，LongAdder 會直接使用 base 變數作為原子操作變數，通過 CAS 操作修改變數；當有多個寫執行緒競爭的情況下，除了佔用 base 變數的一個寫執行緒之外，其它各個執行緒會將修改的變數寫入到自己的槽 cell[] 陣列中。

一個測試用例：

@Test
public void testLongAdder() {
    LongAdder longAdder = new LongAdder();
    longAdder.add(1);
    System.out.println(longAdder.longValue());
}

先看裡面的 longAdder.longValue() 程式碼：

public long longValue() {
    return sum();
}

最終是呼叫了 sum() 方法，是對裡面的 cells 陣列每項加起來求和。這個值在讀取的時候並不準，因為這期間可能有其他執行緒在併發修改 cells 中某個項的值：

public long sum() {
    Cell[] cs = cells;
    long sum = base;
    if (cs != null) {
        for (Cell c : cs)
            if (c != null)
                sum += c.value;
    }
    return sum;
}

add() 方法原始碼：

public void add(long x) {
    Cell[] cs; long b, v; int m; Cell c;
    if ((cs = cells) != null || !casBase(b = base, b + x)) {
        boolean uncontended = true;
        if (cs == null || (m = cs.length - 1) < 0 ||
            (c = cs[getProbe() & m]) == null ||
            !(uncontended = c.cas(v = c.value, v + x)))
            longAccumulate(x, null, uncontended);
    }
}

add 具體的程式碼本篇文章就不詳細敘述了~

公眾號

coding 筆記、點滴記錄，以後的文章也會同步到公眾號（Coding Insight）中，希望大家關注^_

程式碼和思維導圖在 GitHub 專案中，歡迎大家 star！