高級Java多線程：從同步到無鎖算法

synchronized是Java最早的同步機制，簡單易用且經優化後性能良好，但缺乏靈活性；2. ReentrantLock提供可中斷、可重入、支持公平性等高級功能，適用於需精細控制的場景；3. 無鎖算法基於CAS實現非阻塞並發，如AtomicLong、LongAdder和ConcurrentLinkedQueue，在高競爭環境下性能更優，但需處理ABA問題和CPU自旋開銷；最終應根據並發強度選擇合適策略：低競爭用synchronized，需控制用ReentrantLock，高並發場景用無鎖結構，從而實現從基礎同步到高性能並發的演進。

Java 的多線程編程從早期的synchronized關鍵字，逐步演進到更靈活的Lock框架，再到如今高性能場景下廣泛使用的無鎖（Lock-Free）算法。掌握這一演進路徑，不僅有助於寫出更高效的並發程序，也能深入理解現代JVM 和硬件層面的並發機制。

下面從三個層次來解析： synchronized → 顯式鎖（ ReentrantLock ） → 無鎖算法（Lock-Free），帶你從基礎走向高級。

1. synchronized：最原始但依然高效的同步機制

synchronized是Java 最早提供的線程同步關鍵字，可用於方法或代碼塊，確保同一時刻只有一個線程能進入臨界區。

 public synchronized void increment() {
    count ;
}

優點：

• 簡單易用，JVM 自動管理鎖的獲取與釋放。
• 在JDK 1.6 之後經過大量優化（偏向鎖、輕量級鎖、鎖膨脹等），性能已大幅提升。

缺點：

• 不可中斷，線程阻塞時無法響應中斷。
• 無法嘗試加鎖（沒有tryLock）。
• 不支持公平性控制。
• 鎖粒度較粗，靈活性差。

儘管如此，在大多數普通並發場景中， synchronized依然是首選，因為它的性能已經非常接近顯式鎖，且不易出錯。

2. 顯式鎖（Lock）：更靈活的控制

Java 5 引入了java.util.concurrent.locks.Lock接口，最常用的是ReentrantLock ，它提供了比synchronized更豐富的功能。

 private final ReentrantLock lock = new ReentrantLock();

public void increment() {
    lock.lock();
    try {
        count ;
    } finally {
        lock.unlock();
    }
}

主要優勢：

• 支持可中斷的鎖獲取（ lockInterruptibly() ）
• 支持嘗試加鎖（ tryLock() ），避免無限等待
• 支持公平鎖（構造時傳入true ），減少線程飢餓
• 更細粒度的Condition控制（ Condition ）

使用建議：

• 當你需要超時嘗試、中斷響應或公平性時，使用ReentrantLock 。
• 必須配合try-finally使用，否則容易發生死鎖。

但注意：顯式鎖依然是“阻塞式”的，線程拿不到鎖就會被掛起，上下文切換帶來開銷。

3. 無鎖（Lock-Free）算法：基於CAS 的非阻塞並發

真正的高性能並發，尤其是在高競爭場景（如高頻交易、高並發計數器、無鎖隊列），需要擺脫“鎖”的概念，轉向Lock-Free或Wait-Free算法。

其核心是CAS（Compare-And-Swap）操作，由Unsafe類提供，Java 中通過java.util.concurrent.atomic包封裝。

CAS 原理：

 // 偽代碼：僅噹噹前值等於expect 時，才更新為update
boolean compareAndSet(int expect, int update);

示例：原子整數計數器

private final AtomicLong counter = new AtomicLong(0);

public void increment() {
    counter.incrementAndGet(); // 內部基於CAS 循環}

CAS 的ABA 問題

CAS 只比較值是否相等，不關心中間是否被修改過。例如：

• 線程1讀取值A
• 線程2 將A → B → A
• 線程1 執行CAS(A, new_value)，成功，但中間狀態已被篡改

解決方案：使用AtomicStampedReference ，引入版本號（時間戳）來區分真實變化。

 AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(100, 0);

int stamp = ref.getStamp();
Integer value = ref.getReference();
if (ref.compareAndSet(value, newValue, stamp, stamp 1)) {
    // 成功更新}

4. 高級Lock-Free 數據結構

JDK 提供了一些基於無鎖算法的高性能容器：

1. ConcurrentLinkedQueue

• 無鎖的線程安全隊列
• 基於CAS 實現offer()和poll()
• 適合高並發生產者-消費者場景

2. AtomicIntegerFieldUpdater / AtomicReferenceFieldUpdater

• 可以對普通對象的volatile字段進行原子操作
• 避免為每個字段創建AtomicInteger對象，節省內存

public class Task {
    volatile int state;
    static final AtomicIntegerFieldUpdater<Task> updater =
        AtomicIntegerFieldUpdater.newUpdater(Task.class, "state");

    public boolean setStateIf(int expected, int newValue) {
        return updater.compareAndSet(this, expected, newValue);
    }
}

3. LongAdder vs AtomicLong

• 在高並發累加場景下， LongAdder性能遠超AtomicLong
• 原理：分段累加（類似ConcurrentHashMap 的分段鎖思想），最後匯總

private final LongAdder adder = new LongAdder();

public void increment() {
    adder.increment(); // 高並發下衝突更少}

public long getTotal() {
    return adder.sum(); // 匯總所有段的值}

5. 實現一個簡單的Lock-Free 棧（無鎖棧）

 public class LockFreeStack<T> {
    private final AtomicReference<Node<T>> top = new AtomicReference<>();

    private static class Node<T> {
        final T value;
        final Node<T> next;

        Node(T value, Node<T> next) {
            this.value = value;
            this.next = next;
        }
    }

    public void push(T value) {
        Node<T> newHead = new Node<>(value, null);
        Node<T> currentHead;
        do {
            currentHead = top.get();
            newHead = new Node<>(value, currentHead);
        } while (!top.compareAndSet(currentHead, newHead));
    }

    public T pop() {
        Node<T> currentHead;
        Node<T> newHead;
        do {
            currentHead = top.get();
            if (currentHead == null) return null;
            newHead = currentHead.next;
        } while (!top.compareAndSet(currentHead, newHead));
        return currentHead.value;
    }
}

這個棧使用AtomicReference和CAS 實現push/pop，全程無鎖，但需注意：

• 循環重試（spin）可能消耗CPU
• 不適合長時間操作

總結：從synchronized 到Lock-Free 的演進邏輯

使用建議

• 普通場景優先用synchronized ，足夠快且安全。
• 需要超時、中斷、公平性時用ReentrantLock 。
• 高並發計數、狀態更新用AtomicXXX或LongAdder 。
• 構建高性能隊列、棧等結構時，考慮ConcurrentLinkedQueue或手寫CAS 結構。
• 注意：無鎖≠ 無代價，CAS 失敗重試可能帶來CPU 浪費，需結合場景評估。

基本上就這些。掌握這些層次，你就能在不同並發強度下選擇最合適的同步策略，從“會用鎖”走向“懂並發”。

以上是高級Java多線程：從同步到無鎖算法的詳細內容。更多資訊請關注PHP中文網其他相關文章！