ReentrantLock与Condition线程通信详解

Java中ReentrantLock配合Condition能实现比synchronized更精细、更安全的线程协作，通过为同一把锁创建多个独立等待队列（如notFull和notEmpty），精准控制不同条件下的线程阻塞与唤醒，有效避免虚假唤醒，显著提升生产者-消费者等典型并发场景的可靠性与灵活性——掌握这一组合，是写出高效、健壮多线程代码的关键进阶技能。

在Java中，ReentrantLock 提供了比 synchronized 更灵活的锁机制，而结合 Condition 可以实现更精确的线程等待与通知。相比传统的 wait/notify，Condition 允许一个锁创建多个等待条件，从而实现更复杂的线程协作场景。

Condition 的基本原理

每个 Condition 实例都由 ReentrantLock 创建，通过 lock.newCondition() 获取。它提供了类似 Object 的 wait、notify 和 notifyAll 方法，分别是：

• await()：当前线程释放锁并进入等待状态
• signal()：唤醒一个等待中的线程
• signalAll()：唤醒所有等待中的线程

使用 Condition 能避免虚假唤醒，并支持多个独立的等待队列。

生产者-消费者模型示例

下面是一个典型的生产者-消费者问题，使用 ReentrantLock 和 Condition 实现线程间通信：

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumerExample {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int MAX_SIZE = 5;

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 1; i <= 10; i++) {
                lock.lock();
                try {
                    while (queue.size() == MAX_SIZE) {
                        System.out.println("队列已满，生产者等待...");
                        notFull.await(); // 等待空间
                    }
                    queue.offer(i);
                    System.out.println("生产: " + i);
                    notEmpty.signal(); // 通知消费者可以消费
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (queue.isEmpty()) {
                        System.out.println("队列为空，消费者等待...");
                        notEmpty.await(); // 等待数据
                    }
                    Integer value = queue.poll();
                    System.out.println("消费: " + value);
                    notFull.signal(); // 通知生产者可以生产
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producer = new Thread(example.new Producer());
        Thread consumer = new Thread(example.new Consumer());

        producer.start();
        consumer.start();
    }
}

关键点说明与最佳实践

上述代码展示了 Condition 的典型用法，以下是需要注意的关键细节：

• 必须在 lock() 和 unlock() 之间调用 await()/signal()，否则会抛出 IllegalMonitorStateException
• 使用 while 判断条件而非 if，防止虚假唤醒或多个线程被唤醒时状态再次不满足
• signal() 唤醒至少一个等待线程，但具体唤醒哪个取决于调度策略；若需唤醒全部，使用 signalAll()
• 多个 Condition 可以实现不同条件下的等待，比如读锁和写锁分离

基本上就这些。ReentrantLock 配合 Condition 不仅提升了线程通信的灵活性，还让逻辑更清晰可控，适合复杂同步场景的开发。掌握这种模式对理解并发编程非常有帮助。

今天关于《ReentrantLock与Condition线程通信详解》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！