Java 条件变量：深入理解与高效使用

简介

在多线程编程中，线程之间的协调与同步是一个关键问题。Java 提供了多种机制来实现线程同步，其中条件变量（Conditional Variable）是一种强大且灵活的工具。条件变量允许线程在某个条件不满足时挂起，等待其他线程改变条件状态并通知它，从而避免了线程的忙等待，提高了程序的性能和效率。本文将详细介绍 Java 条件变量的基础概念、使用方法、常见实践以及最佳实践，帮助读者深入理解并高效使用这一重要的多线程编程工具。

基础概念

什么是条件变量

条件变量是一种同步原语，用于线程之间的协调。它通常与锁（如 ReentrantLock）一起使用，允许线程在某个条件不满足时进入等待状态，直到其他线程通知该条件已经满足。条件变量提供了两个主要操作： - await()：当前线程释放持有的锁，并进入等待状态，直到其他线程调用 signal() 或 signalAll() 方法唤醒它。 - signal()：唤醒一个在该条件变量上等待的线程。 - signalAll()：唤醒所有在该条件变量上等待的线程。

与 `synchronized` 和 `wait()`、`notify()`、`notifyAll()` 的关系

Java 中的 synchronized 关键字和 wait()、notify()、notifyAll() 方法也可以实现线程之间的同步和协调。条件变量与它们类似，但提供了更灵活的功能。synchronized 是基于对象的内置锁，而条件变量可以与 ReentrantLock 结合使用，允许多个条件变量与同一个锁关联，从而实现更细粒度的控制。

使用方法

创建条件变量

在 Java 中，条件变量是通过 Lock 接口的 newCondition() 方法创建的。以下是一个简单的示例：

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

public class ConditionVariableExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();

    public void doWork() {
        lock.lock();
        try {
            // 检查条件
            while (!isConditionMet()) {
                // 条件不满足，线程等待
                condition.await();
            }
            // 条件满足，执行工作
            System.out.println("Condition is met, doing work...");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    public void signalCondition() {
        lock.lock();
        try {
            // 改变条件状态
            setConditionMet(true);
            // 通知等待的线程
            condition.signal();
        } finally {
            lock.unlock();
        }
    }

    private boolean isConditionMet() {
        // 检查条件是否满足
        return false;
    }

    private void setConditionMet(boolean met) {
        // 设置条件状态
    }
}

使用步骤

创建一个 Lock 对象（如 ReentrantLock）。
通过 Lock 对象的 newCondition() 方法创建一个条件变量。
在需要等待条件的线程中，获取锁，检查条件是否满足。如果不满足，调用条件变量的 await() 方法进入等待状态。
在其他线程中，获取锁，改变条件状态，并调用条件变量的 signal() 或 signalAll() 方法通知等待的线程。
最后，释放锁。

常见实践

生产者 - 消费者模式

生产者 - 消费者模式是多线程编程中常见的模式，用于解决生产者和消费者之间的同步问题。以下是一个使用条件变量实现的生产者 - 消费者模式的示例：

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 ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 10;

    public void produce(int item) throws InterruptedException {
        lock.lock();
        try {
            // 队列已满，生产者等待
            while (queue.size() == capacity) {
                notFull.await();
            }
            // 生产一个元素
            queue.add(item);
            System.out.println("Produced: " + item);
            // 通知消费者队列非空
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            // 队列为空，消费者等待
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            // 消费一个元素
            int item = queue.poll();
            System.out.println("Consumed: " + item);
            // 通知生产者队列非满
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

线程协作

条件变量还可以用于线程之间的协作，例如一个线程等待另一个线程完成某个任务。以下是一个简单的示例：

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

public class ThreadCooperationExample {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition taskCompleted = lock.newCondition();
    private boolean isTaskCompleted = false;

    public void performTask() {
        lock.lock();
        try {
            // 执行任务
            System.out.println("Performing task...");
            // 模拟任务完成
            Thread.sleep(1000);
            isTaskCompleted = true;
            // 通知等待的线程
            taskCompleted.signal();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }

    public void waitForTaskCompletion() {
        lock.lock();
        try {
            // 等待任务完成
            while (!isTaskCompleted) {
                taskCompleted.await();
            }
            System.out.println("Task is completed.");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock();
        }
    }
}

最佳实践

避免死锁

在使用条件变量时，要确保线程在调用 await() 方法之前已经获取了锁，并且在调用 signal() 或 signalAll() 方法时也持有锁。同时，要注意锁的释放顺序，避免死锁的发生。

正确处理中断

await() 方法可能会抛出 InterruptedException 异常，因此在捕获该异常时，要正确处理中断状态，通常是恢复中断状态，以便其他代码可以检测到中断。

使用 `while` 循环检查条件

在调用 await() 方法之前，要使用 while 循环检查条件是否满足，而不是 if 语句。这是因为线程在被唤醒后，条件可能仍然不满足，需要再次检查。

小结

Java 条件变量是一种强大的多线程编程工具，它与锁结合使用，允许线程在某个条件不满足时进入等待状态，直到其他线程通知该条件已经满足。通过本文的介绍，我们了解了条件变量的基础概念、使用方法、常见实践以及最佳实践。在实际应用中，合理使用条件变量可以提高程序的性能和效率，避免线程的忙等待，实现线程之间的高效协调与同步。

参考资料

《Effective Java》（第三版），作者：Joshua Bloch
《Java 并发编程实战》，作者：Brian Goetz 等