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来解决。