Java多線程之常見鎖策略與CAS中的ABA問題怎么解決

Java多線程之常見鎖策略與CAS中的ABA問題怎么解決

在多線程編程中，鎖策略和CAS（Compare-And-Swap）是保證線程安全的重要手段。然而，CAS操作中可能會遇到ABA問題，本文將介紹常見的鎖策略以及如何解決CAS中的ABA問題。

1. 常見鎖策略

1.1 悲觀鎖與樂觀鎖

• 悲觀鎖：假設最壞的情況，認為每次訪問共享資源時都會發生沖突，因此在訪問資源前會先加鎖。常見的悲觀鎖實現有synchronized關鍵字和ReentrantLock。
• 樂觀鎖：假設最好的情況，認為每次訪問共享資源時不會發生沖突，因此在訪問資源時不會加鎖，而是在更新資源時檢查是否有沖突。常見的樂觀鎖實現有CAS操作。

1.2 公平鎖與非公平鎖

• 公平鎖：按照線程請求鎖的順序來獲取鎖，保證先到先得的原則。ReentrantLock可以通過構造函數指定是否為公平鎖。
• 非公平鎖：不保證線程獲取鎖的順序，可能會導致某些線程長時間無法獲取鎖。ReentrantLock默認是非公平鎖。

1.3 可重入鎖

• 可重入鎖：同一個線程可以多次獲取同一把鎖，而不會發生死鎖。synchronized和ReentrantLock都是可重入鎖。

1.4 讀寫鎖

• 讀寫鎖：允許多個線程同時讀取共享資源，但在寫操作時需要獨占鎖。ReentrantReadWriteLock是Java中常見的讀寫鎖實現。

2. CAS與ABA問題

2.1 CAS操作

CAS（Compare-And-Swap）是一種無鎖算法，通過比較內存中的值與預期值是否相等來決定是否更新內存中的值。CAS操作通常用于實現樂觀鎖。

public class CASExample {
    private AtomicInteger atomicInteger = new AtomicInteger(0);

    public void increment() {
        int oldValue;
        int newValue;
        do {
            oldValue = atomicInteger.get();
            newValue = oldValue + 1;
        } while (!atomicInteger.compareAndSet(oldValue, newValue));
    }
}

2.2 ABA問題

ABA問題是指在進行CAS操作時，內存中的值從A變為B，然后又變回A，此時CAS操作會認為值沒有發生變化，但實際上值已經發生了變化。這種情況可能會導致程序邏輯錯誤。

2.3 解決ABA問題的方法

2.3.1 版本號機制

通過引入版本號機制，每次更新值時同時更新版本號，CAS操作不僅要比較值，還要比較版本號。

public class AtomicStampedReference<V> {
    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

    public AtomicStampedReference(V initialRef, int initialStamp) {
        pair = Pair.of(initialRef, initialStamp);
    }

    public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) {
        Pair<V> current = pair;
        return expectedReference == current.reference &&
               expectedStamp == current.stamp &&
               ((newReference == current.reference && newStamp == current.stamp) ||
                casPair(current, Pair.of(newReference, newStamp)));
    }

    private boolean casPair(Pair<V> cmp, Pair<V> val) {
        return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
    }

    // 省略其他方法
}

2.3.2 使用AtomicStampedReference

Java提供了AtomicStampedReference類來解決ABA問題，它通過維護一個版本號來避免ABA問題。

public class ABAExample {
    private AtomicStampedReference<Integer> atomicStampedRef = new AtomicStampedReference<>(0, 0);

    public void update(int newValue) {
        int[] stampHolder = new int[1];
        int oldValue = atomicStampedRef.get(stampHolder);
        if (atomicStampedRef.compareAndSet(oldValue, newValue, stampHolder[0], stampHolder[0] + 1)) {
            System.out.println("Update successful");
        } else {
            System.out.println("Update failed");
        }
    }
}

3. 總結

在多線程編程中，選擇合適的鎖策略和解決CAS中的ABA問題是保證線程安全的關鍵。悲觀鎖和樂觀鎖各有優缺點，應根據具體場景選擇合適的鎖策略。對于CAS操作中的ABA問題，可以通過版本號機制或使用AtomicStampedReference來解決。