Java中如何用Condition实现线程间通信-Java-PHP中文网

Java中如何用Condition实现线程间通信

冰火之心

发布： 2025-06-26 08:06:02

原创

192人浏览过

condition在java中确实可以看作是lock锁的增强版，它通过await()和signal()/signalall()提供更细粒度的线程同步机制。1. await()用于线程等待并释放锁；2. signal()唤醒一个等待线程，signalall()唤醒所有等待线程。与wait()/notify()相比，condition必须显式绑定到lock，支持多个等待队列，从而实现更灵活的控制。例如，在生产者-消费者模型中使用notfull和notempty两个condition分别管理缓冲区状态。使用condition时应在循环中检查条件以防止虚假唤醒或条件变化导致的错误。选择signal()还是signalall()取决于是否需要唤醒单个或多个线程，signalall()通常更安全。当需要更精细的线程控制或多等待队列时应使用condition，简单场景可继续使用wait()/notify()。

Java中如何用Condition实现线程间通信

Condition在Java中可以看作是Lock锁的增强版，它允许线程在满足特定条件时挂起（等待），并在其他线程改变条件后被唤醒。这提供了一种比wait()/notify()更细粒度的线程同步机制。

解决方案

Condition接口的核心在于await()（等待）和signal()/signalAll()（通知）。await()类似于Object.wait()，它释放锁并让线程进入等待状态，直到被signal()或signalAll()唤醒。signal()唤醒一个等待的线程，signalAll()唤醒所有等待的线程。

立即学习“Java免费学习笔记（深入）”；

下面是一个简单的例子，展示了如何使用Condition实现生产者-消费者模型：

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

public class ProducerConsumer {

    private final Queue<Integer> buffer = new LinkedList<>();
    private final int maxSize = 10;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == maxSize) {
                notFull.await(); // 缓冲区已满，等待消费者消费
            }
            buffer.offer(value);
            System.out.println("Produced: " + value);
            notEmpty.signalAll(); // 通知消费者可以消费
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await(); // 缓冲区为空，等待生产者生产
            }
            int value = buffer.poll();
            System.out.println("Consumed: " + value);
            notFull.signalAll(); // 通知生产者可以生产
            return value;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // 生产者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.produce(i);
                    Thread.sleep((long) (Math.random() * 100)); // 模拟生产时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 消费者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.consume();
                    Thread.sleep((long) (Math.random() * 150)); // 模拟消费时间
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

登录后复制

Condition和wait()/notify()的区别是什么？什么时候应该使用Condition？

wait()/notify()是Java内置的对象监视器机制的一部分，每个对象都关联一个监视器锁。Condition则必须与Lock一起使用，提供更灵活的线程同步控制。

锁的绑定: wait()/notify()隐式地与对象的内置锁绑定，而Condition需要显式地与Lock关联。
多个等待队列: 一个对象只有一个等待队列用于wait()，而一个Lock可以创建多个Condition对象，每个Condition对象都有自己的等待队列。这允许更细粒度的线程调度和唤醒。比如，在上面的生产者-消费者模型中，我们使用notFull和notEmpty两个Condition，分别对应缓冲区满和缓冲区空两种等待状态。
灵活性: Condition提供了更丰富的API，例如awaitUninterruptibly()（不可中断的等待）、awaitNanos()（带超时时间的等待）等。

当需要更精细的线程控制，或者需要多个等待队列时，应该使用Condition。如果简单的同步需求，wait()/notify()可能就足够了。选择哪个取决于具体场景的复杂程度。