当前位置：首页 > news >正文

Java 显式锁与 Condition 的使用详解

news 2025/5/9 15:40:44

Java 显式锁与 Condition 的使用详解

在多线程编程中，线程间的协作与同步是核心问题。Java 提供了多种机制来实现线程同步，除了传统的 synchronized 关键字外，ReentrantLock 和 Condition 是更灵活且功能强大的替代方案。本文将详细介绍显式锁与 Condition 的使用，并通过实际案例分析其工作原理及常见误区。

一、显式锁与 Condition 简介

1. 显式锁（ReentrantLock）

ReentrantLock 是 Java 提供的可重入互斥锁，它比 synchronized 提供了更高的灵活性：

支持尝试加锁（tryLock()）。
支持超时等待。
支持公平锁与非公平锁。
可以绑定多个 Condition 条件变量。

2. Condition 条件变量

Condition 是与 ReentrantLock 绑定的条件队列，用于实现线程的等待和唤醒。它替代了传统的 Object.wait() 和 Object.notify()，并且支持为不同的条件定义独立的等待队列，从而更精确地控制线程协作。

二、典型使用场景：生产者-消费者模型

以下是一个使用 ReentrantLock 和 Condition 实现的**有界缓冲区（Bounded Buffer）**示例：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;public class BoundedBuffer<T> {private final List<T> buffer;private final int capacity;private final Lock lock = new ReentrantLock();private final Condition notFull = lock.newCondition();private final Condition notEmpty = lock.newCondition();public BoundedBuffer(int capacity) {this.capacity = capacity;this.buffer = new ArrayList<>();}public void put(T item) throws InterruptedException {lock.lock();try {while (buffer.size() == capacity) {notFull.await(); // 缓冲区满时等待}buffer.add(item);notEmpty.signal(); // 通知消费者缓冲区非空} finally {lock.unlock();}}public T take() throws InterruptedException {lock.lock();try {while (buffer.isEmpty()) {notEmpty.await(); // 缓冲区空时等待}T item = buffer.remove(0);notFull.signal(); // 通知生产者缓冲区有空间return item;} finally {lock.unlock();}}
}

主程序：启动生产者与消费者线程

public class ProducerConsumerExample {public static void main(String[] args) {BoundedBuffer<Integer> buffer = new BoundedBuffer<>(10);Thread producer = new Thread(() -> {try {for (int i = 0; i < 20; i++) {buffer.put(i);System.out.println("Produced: " + i);Thread.sleep(100);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});Thread consumer = new Thread(() -> {try {for (int i = 0; i < 20; i++) {Integer item = buffer.take();System.out.println("Consumed: " + item);Thread.sleep(150);}} catch (InterruptedException e) {Thread.currentThread().interrupt();}});producer.start();consumer.start();}
}

示例说明

ReentrantLock：通过 lock.lock() 和 lock.unlock() 控制对共享资源的访问。
Condition：notFull 和 notEmpty 分别用于生产者和消费者线程的等待与唤醒。
while 循环：用于防止虚假唤醒（Spurious Wakeup），确保条件满足后再继续执行。

三、常见误区：不加锁调用 Condition.await()

❌ 错误示例

Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();// 未加锁直接调用 await()
condition.await(); // 抛出 IllegalMonitorStateException

✅ 正确做法

必须在持有锁的情况下调用 await()：

lock.lock();
try {while (!conditionMet) {condition.await(); // 必须持有锁}
} finally {lock.unlock();
}

🔒 为什么必须加锁？

原子性释放锁与等待：
- await() 的设计要求线程在调用时持有锁，以便在等待前释放锁，防止死锁。
- 如果未持有锁，线程无法确定要释放哪个锁，导致逻辑混乱。
Java 的强制性检查：
- Condition 内部会检查当前线程是否持有锁。若未持有，会抛出 IllegalMonitorStateException。
与 Object.wait() 的类比：
- Object.wait() 必须在 synchronized 块中调用。
- Condition.await() 必须在 ReentrantLock.lock() 保护的代码块中调用。

四、最佳实践

始终使用 while 而不是 if：
- 防止虚假唤醒（Spurious Wakeup），确保条件再次检查。
在 finally 块中释放锁：
- 避免因异常导致锁未释放，造成死锁。
选择 signal 或 signalAll：
- signal() 唤醒单个线程，适用于单一条件满足的场景。
- signalAll() 唤醒所有等待线程，适用于复杂条件变化的场景。
避免在无锁状态下操作 Condition：
- 所有 await()、signal() 操作必须在持有锁的上下文中执行。