如何理解Java多线程乐观锁和CAS机制

# 如何理解Java多线程乐观锁和CAS机制

## 目录
1. [多线程并发问题的本质](#一多线程并发问题的本质)
2. [乐观锁与悲观锁的哲学差异](#二乐观锁与悲观锁的哲学差异)
3. [CAS机制原理解析](#三cas机制原理解析)
4. [Java中的CAS实现](#四java中的cas实现)
5. [CAS的典型应用场景](#五cas的典型应用场景)
6. [CAS的缺陷与解决方案](#六cas的缺陷与解决方案)
7. [总结与最佳实践](#七总结与最佳实践)

---

### 一、多线程并发问题的本质

在多线程编程中，核心矛盾在于**共享资源的可见性**和**操作原子性**问题。当多个线程同时访问共享变量时，会出现三类典型问题：

1. **竞态条件（Race Condition）**  
   例如两个线程同时执行`i++`操作，由于非原子性可能导致结果不符合预期

2. **内存可见性问题**  
   由于CPU缓存的存在，线程可能读取到过期的数据

3. **指令重排序问题**  
   JVM和处理器可能优化指令执行顺序

传统解决方案是使用`synchronized`关键字，但这种悲观锁会带来显著的性能开销：

```java
// 悲观锁示例
public synchronized void increment() {
    counter++;
}

// CAS伪代码
boolean compareAndSwap(V expected, V newValue) {
    if (this.value == expected) {
        this.value = newValue;
        return true;
    }
    return false;
}

public class AtomicInteger {
    private volatile int value;
    
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
}

public final native boolean compareAndSwapInt(
    Object o, long offset, 
    int expected, int x
);

// JDK1.8的LongAdder实现
public void add(long x) {
    Cell[] as; long b, v; int m; Cell a;
    if ((as = cells) != null || !casBase(b = base, b + x)) {
        // 使用分段CAS减少竞争
    }
}

AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();

public class ConcurrentStack<E> {
    AtomicReference<Node<E>> top = new AtomicReference<>();
    
    public void push(E item) {
        Node<E> newHead = new Node<>(item);
        Node<E> oldHead;
        do {
            oldHead = top.get();
            newHead.next = oldHead;
        } while (!top.compareAndSet(oldHead, newHead));
    }
}

// StampedLock的乐观读示例
double distanceFromOrigin() {
    long stamp = sl.tryOptimisticRead();
    double currentX = x, currentY = y;
    if (!sl.validate(stamp)) {
        stamp = sl.readLock();
        try {
            currentX = x;
            currentY = y;
        } finally {
            sl.unlockRead(stamp);
        }
    }
    return Math.sqrt(currentX*currentX + currentY*currentY);
}

AtomicStampedReference<Integer> atomicRef = 
    new AtomicStampedReference<>(100, 0);
int stamp = atomicRef.getStamp();
atomicRef.compareAndSet(100, 101, stamp, stamp+1);

public class AtomicPair {
    private static class Pair {
        final int first, second;
        // 构造方法省略
    }
    
    private final AtomicReference<Pair> values = ...;
}