Java CompletableFuture 异步编排实战

## 引言

锁是 Java 并发编程的基础设施。从最古老的 `synchronized` 到 JDK 5 引入的 `ReentrantLock`，再到 JDK 8 的 `StampedLock`，Java 的锁机制经历了从 JVM 内置到 API 化再到乐观读的演进。理解每种锁的原理和适用场景，是写出高效并发代码的前提。

---

## 一、synchronized

### 1.1 基本用法

```java

// 1. 修饰实例方法：锁当前实例

public synchronized void method() {

// 同步代码

}

// 2. 修饰静态方法：锁当前类的 Class 对象

public static synchronized void staticMethod() {

// 同步代码

}

// 3. 修饰代码块：锁指定对象

public void method() {

synchronized (lock) {

// 同步代码

}

}

```

### 1.2 锁的原理：Monitor

```

每个 Java 对象关联一个 Monitor（监视器）

synchronized 进入：

monitorenter → 获取 Monitor 锁

synchronized 退出：

monitorexit → 释放 Monitor 锁

Monitor 结构：

┌────────────────────────────┐

│ _owner → 持有锁的线程 │

│ _entry_set → 等待获取锁 │

│ _wait_set → 调用 wait() │

└────────────────────────────┘

```

### 1.3 锁升级（偏向锁 → 轻量级锁 → 重量级锁）

JDK 6 引入锁升级优化，`synchronized` 不再总是重量级锁：

```

无锁 → 偏向锁 → 轻量级锁 → 重量级锁

│ │ │ │

│ │ │ └─ 竞争激烈，OS 互斥量

│ │ └─ 自旋等待（CAS），适合短时间竞争

│ └─ 同一线程重复获取，无竞争，CAS 都不需要

└─ 对象刚创建，无任何线程访问

升级是单向的（不可降级，G1 下有例外）

```

| 锁状态 | 适用场景 | 获取方式 | 性能 |

|--------|----------|----------|------|

| 偏向锁 | 同一线程反复获取 | 检查偏向线程 ID | 最优 |

| 轻量级锁 | 交替执行，低竞争 | CAS 自旋 | 优 |

| 重量级锁 | 高竞争 | OS 互斥量 | 差 |

### 1.4 优缺点

| 优点 | 缺点 |

|------|------|

| JVM 内置，使用简单 | 无法中断等待锁的线程 |

| 锁升级自动优化 | 无法设置超时 |

| 异常自动释放锁 | 不支持公平锁 |

| 可重入 | 不支持条件变量（Condition） |

| | 在虚拟线程中会导致固定（Pinning） |

---

## 二、ReentrantLock

### 2.1 基本用法

```java

private final ReentrantLock lock = new ReentrantLock();

public void method() {

lock.lock();

try {

// 同步代码

} finally {

lock.unlock(); // 必须在 finally 中释放

}

}

```

### 2.2 公平锁 vs 非公平锁

```java

// 非公平锁（默认）：新来的线程可能插队

ReentrantLock unfairLock = new ReentrantLock();

// 公平锁：按等待顺序获取锁

ReentrantLock fairLock = new ReentrantLock(true);

```

| 对比 | 非公平锁 | 公平锁 |

|------|----------|--------|

| 获取顺序 | 可能插队 | FIFO 排队 |

| 吞吐量 | 高 | 低 |

| 饥饿风险 | 有（线程可能永远等不到） | 无 |

| 实现原理 | CAS 直接尝试 | 先入队列排队 |

### 2.3 可中断锁

```java

ReentrantLock lock = new ReentrantLock();

Thread t = new Thread(() -> {

try {

lock.lockInterruptibly(); // 可被中断的锁获取

try {

doWork();

} finally {

lock.unlock();

}

} catch (InterruptedException e) {

System.out.println("被中断，放弃获取锁");

}

});

t.start();

Thread.sleep(1000);

t.interrupt(); // 中断等待锁的线程

```

### 2.4 超时获取锁

```java

ReentrantLock lock = new ReentrantLock();

if (lock.tryLock()) {

try {

doWork();

} finally {

lock.unlock();

}

} else {

System.out.println("获取锁失败，执行降级逻辑");

}

// 带超时

if (lock.tryLock(5, TimeUnit.SECONDS)) {

try {

doWork();

} finally {

lock.unlock();

}

} else {

System.out.println("5秒内未获取锁");

}

```

### 2.5 Condition 条件变量

```java

// synchronized 只有一个 wait set

// ReentrantLock 支持多个 Condition，实现精准唤醒

private final ReentrantLock lock = new ReentrantLock();

private final Condition notFull = lock.newCondition();

private final Condition notEmpty = lock.newCondition();

private final Object[] items = new Object[10];

private int count, putIdx, takeIdx;

public void put(Object item) throws InterruptedException {

lock.lock();

try {

while (count == items.length) {

notFull.await(); // 队列满，等待 notFull 条件

}

items[putIdx] = item;

if (++putIdx == items.length) putIdx = 0;

count++;

notEmpty.signal(); // 通知消费者

} finally {

lock.unlock();

}

}

public Object take() throws InterruptedException {

lock.lock();

try {

while (count == 0) {

notEmpty.await(); // 队列空，等待 notEmpty 条件

}

Object item = items[takeIdx];

items[takeIdx] = null;

if (++takeIdx == items.length) takeIdx = 0;

count--;

notFull.signal(); // 通知生产者

return item;

} finally {

lock.unlock();

}

}

```

### 2.6 synchronized vs ReentrantLock

| 对比 | synchronized | ReentrantLock |

|------|-------------|---------------|

| 实现 | JVM 内置 | JDK API（AQS） |

| 锁获取 | 自动 | 手动 lock/unlock |

| 可中断 | ❌ | ✅ lockInterruptibly |

| 超时 | ❌ | ✅ tryLock(timeout) |

| 公平性 | 非公平 | 可选公平/非公平 |

| 条件变量 | wait/notify（一个） | Condition（多个） |

| 锁升级 | 偏向→轻量→重量 | 无 |

| 虚拟线程 | 固定（Pinning） | 正常卸载 |

| 异常安全 | 自动释放 | 需 finally 手动释放 |

---

## 三、ReadWriteLock

### 3.1 读写分离

```java

// 读读不互斥，读写互斥，写写互斥

private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

private final Lock readLock = rwLock.readLock();

private final Lock writeLock = rwLock.writeLock();

private Map<String, Data> cache = new HashMap<>();

public Data get(String key) {

readLock.lock();

try {

return cache.get(key);

} finally {

readLock.unlock();

}

}

public void put(String key, Data value) {

writeLock.lock();

try {

cache.put(key, value);

} finally {

writeLock.unlock();

}

}

```

### 3.2 ReentrantReadWriteLock 特性

| 特性 | 说明 |

|------|------|

| 公平性 | 支持公平/非公平模式 |

| 重入 | 读锁和写锁都支持重入 |

| 锁降级 | 写锁可降级为读锁（获取写锁→获取读锁→释放写锁） |

| 锁升级 | 读锁不能升级为写锁（会死锁） |

```java

// 锁降级：写锁 → 读锁

writeLock.lock();

try {

updateData();

readLock.lock(); // 获取读锁

} finally {

writeLock.unlock(); // 释放写锁，此时持有读锁

}

try {

readData(); // 在读锁保护下读取

} finally {

readLock.unlock();

}

```

### 3.3 读写锁的问题

- **写饥饿**：读操作频繁时，写线程可能长时间获取不到写锁

- **不支持乐观读**：即使只是读取，也需要获取读锁

---

## 四、StampedLock

### 4.1 核心思想

StampedLock 在 ReadWriteLock 基础上引入了**乐观读（Optimistic Read）**：

```

ReadWriteLock：

读锁 → 获取读锁 → 读取 → 释放读锁（每次都要 CAS）

StampedLock：

乐观读 → 获取戳 → 读取 → 验证戳 → 成功则无需 CAS

→ 失败则升级为读锁重试

```

### 4.2 三种模式

| 模式 | 说明 | 类比 |

|------|------|------|

| 写锁（Writing） | 独占锁，与读锁互斥 | ReadWriteLock 的写锁 |

| 读锁（Reading） | 共享锁，与写锁互斥 | ReadWriteLock 的读锁 |

| 乐观读（Optimistic Reading） | 无锁读取，验证后使用 | 数据库的乐观锁 |

### 4.3 基本用法

```java

private final StampedLock sl = new StampedLock();

private double x, y;

// 写操作

void move(double deltaX, double deltaY) {

long stamp = sl.writeLock();

try {

x += deltaX;

y += deltaY;

} finally {

sl.unlockWrite(stamp);

}

}

// 乐观读

double distanceFromOrigin() {

long stamp = sl.tryOptimisticRead(); // 1. 获取乐观读戳

double currentX = x, currentY = y; // 2. 读取数据（无锁）

if (!sl.validate(stamp)) { // 3. 验证戳（期间是否有写操作？）

stamp = sl.readLock(); // 4. 验证失败，升级为读锁

try {

currentX = x;

currentY = y;

} finally {

sl.unlockRead(stamp);

}

}

return Math.sqrt(currentX * currentX + currentY * currentY);

}

// 悲观读

double distanceFromOriginPessimistic() {

long stamp = sl.readLock();

try {

return Math.sqrt(x * x + y * y);

} finally {

sl.unlockRead(stamp);

}

}

```

### 4.4 锁转换

```java

// 读锁 → 写锁

long stamp = sl.readLock();

try {

long ws = sl.tryConvertToWriteLock(stamp);

if (ws != 0L) {

stamp = ws;

// 持有写锁

} else {

sl.unlockRead(stamp);

stamp = sl.writeLock();

}

} finally {

sl.unlock(stamp);

}

// 乐观读 → 读锁

long stamp = sl.tryOptimisticRead();

if (!sl.validate(stamp)) {

stamp = sl.readLock();

try {

// 重新读取

} finally {

sl.unlockRead(stamp);

}

}

```

### 4.5 StampedLock 注意事项

| 注意 | 说明 |

|------|------|

| 不可重入 | 同一线程不能重复获取同一锁 |

| 不支持 Condition | 没有 newCondition() 方法 |

| 不要用 interrupt | 不要在 readLock/writeLock 中调用 interrupt |

| unlock 必须传 stamp | 传入错误的 stamp 会抛 IllegalMonitorStateException |

| 乐观读适合读多写少 | 写频繁时乐观读经常失败，反而更慢 |

---

## 五、锁选型指南

### 5.1 决策树

```

需要锁吗？

├─ 能否用无锁方案？（Atomic* / Concurrent集合）

│ ├─ 能 → 优先无锁

│ └─ 不能 ↓

├─ 读多写少？

│ ├─ 是 → 读远多于写？

│ │ ├─ 是 → StampedLock（乐观读）

│ │ └─ 否 → ReentrantReadWriteLock

│ └─ 否 ↓

├─ 需要高级功能？（中断/超时/多条件/公平）

│ ├─ 是 → ReentrantLock

│ └─ 否 → synchronized（简单场景优先）

├─ 在虚拟线程中使用？

│ ├─ 是 → ReentrantLock（避免 synchronized 固定）

│ └─ 否 → synchronized

```

### 5.2 性能对比（大致参考）

```

低竞争：synchronized ≈ ReentrantLock > StampedLock

中竞争：StampedLock > ReentrantLock > synchronized

高竞争：StampedLock(乐观读) >> ReentrantReadWriteLock > ReentrantLock > synchronized

读多写少：StampedLock(乐观读) >> ReentrantReadWriteLock >> synchronized

```

### 5.3 速查表

| 场景 | 推荐锁 | 原因 |

|------|--------|------|

| 简单互斥 | synchronized | 简单，JVM 优化好 |

| 需要中断/超时 | ReentrantLock | lockInterruptibly / tryLock |

| 需要公平锁 | ReentrantLock(true) | synchronized 不支持 |

| 需要多条件唤醒 | ReentrantLock + Condition | synchronized 只有一个 wait set |

| 读多写少 | StampedLock | 乐观读无锁，性能最优 |

| 虚拟线程中 | ReentrantLock | synchronized 导致固定 |

| 缓存场景 | ReentrantReadWriteLock | 读写分离 |

| 高并发点数据 | StampedLock | 乐观读 + 锁转换 |

---

## 六、锁的性能优化技巧

### 6.1 减小锁粒度

```java

// ❌ 锁范围过大

synchronized (this) {

validate(data); // 无需锁

process(data); // 需要锁

log(data); // 无需锁

}

// ✅ 只锁必要部分

validate(data);

synchronized (this) {

process(data);

}

log(data);

```

### 6.2 减小锁粒度（分段锁）

```java

// ❌ 一把大锁

synchronized (allAccounts) {

transfer(from, to, amount);

}

// ✅ 分段锁（类似 ConcurrentHashMap）

private final Object[] locks = new Object[16];

{

for (int i = 0; i < locks.length; i++) locks[i] = new Object();

}

void transfer(Account from, Account to, int amount) {

Object lock1 = locks[Math.abs(from.hashCode() % 16)];

Object lock2 = locks[Math.abs(to.hashCode() % 16)];

// 按固定顺序加锁，避免死锁

Object first = System.identityHashCode(lock1) < System.identityHashCode(lock2) ? lock1 : lock2;

Object second = first == lock1 ? lock2 : lock1;

synchronized (first) {

synchronized (second) {

from.debit(amount);

to.credit(amount);

}

}

}

```

### 6.3 避免锁嵌套

```java

// ❌ 锁嵌套，容易死锁

synchronized (lockA) {

synchronized (lockB) {

doWork();

}

}

// ✅ 拆分：先获取所有锁，再操作

// 或使用 tryLock 避免无限等待

if (lockA.tryLock()) {

try {

if (lockB.tryLock()) {

try {

doWork();

} finally {

lockB.unlock();

}

}

} finally {

lockA.unlock();

}

}

```

---

## 总结

| 锁 | 一句话 | 适用场景 |

|----|--------|----------|

| synchronized | 简单可靠，JVM 优化 | 简单互斥，低竞争 |

| ReentrantLock | 功能丰富，API 灵活 | 需要中断/超时/公平/多条件 |

| ReentrantReadWriteLock | 读写分离 | 读多写少，但写不极少 |

| StampedLock | 乐观读，极致性能 | 读远多于写，追求极致吞吐 |