Java 提供了一种更灵活和高级的线程协作机制，通过 Condition 接口的使用，你可以更精细地控制线程的等待和唤醒，实现更复杂的线程同步和通信。本文将详细介绍 Java 的 Condition 接口，包括它的基本概念、常见用法以及注意事项。

什么是 Condition 接口？

在 Java 多线程编程中，通常使用 wait() 和 notify() 方法来实现线程之间的等待和唤醒操作。但这两个方法有一些局限性，例如，只能在 synchronized 块内调用，而且每个对象只有一个等待队列。Condition 接口的引入弥补了这些不足，它提供了更灵活的线程协作方式。

Condition 接口是 Java 核心库中 java.util.concurrent.locks 包下的一部分，它通常与 ReentrantLock 一起使用。ReentrantLock 是一种可重入锁，与传统的 synchronized 关键字相比，提供了更多的控制和功能。通过 Condition 接口，你可以为每个 ReentrantLock 创建多个条件（Condition），每个条件可以控制一组线程的等待和唤醒。

Condition 接口的主要方法

Condition 接口定义了一些重要的方法，用于线程的等待和唤醒：

• await()：使当前线程等待，并释放锁，直到其他线程调用相同条件上的 signal() 或 signalAll() 方法来唤醒它。
• awaitUninterruptibly()：与 await() 类似，但不响应中断。
• signal()：唤醒一个在该条件上等待的线程。如果有多个线程在等待，只会唤醒其中一个，具体唤醒哪个线程不确定。
• signalAll()：唤醒所有在该条件上等待的线程。

Condition 的基本用法

创建 Condition

要使用 Condition 接口，首先需要创建一个与 ReentrantLock 关联的条件对象。通常，一个 ReentrantLock 对象可以创建多个条件对象，用于不同的线程协作。

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

等待和唤醒线程

在使用 Condition 进行线程协作时，通常遵循以下模式：

等待线程

lock.lock(); // 获取锁
try {
    while (条件不满足) {
        condition.await(); // 释放锁，并等待条件满足
    }
    // 执行线程任务
} finally {
    lock.unlock(); // 释放锁
}

唤醒线程

lock.lock(); // 获取锁
try {
    // 修改条件，使等待线程可以继续执行
    condition.signal(); // 唤醒一个等待线程
    // 或者使用 condition.signalAll() 唤醒所有等待线程
} finally {
    lock.unlock(); // 释放锁
}

示例：生产者和消费者问题

让我们通过一个简单的生产者和消费者问题来演示 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 BoundedBuffer<T> {
    private Queue<T> buffer = new LinkedList<>();
    private int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (buffer.size() == capacity) {
                notFull.await();
            }
            buffer.offer(item);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (buffer.isEmpty()) {
                notEmpty.await();
            }
            T item = buffer.poll();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

在这个示例中，我们使用了 ReentrantLock 来保护缓冲区的操作，并分别创建了两个条件 notFull 和 notEmpty，用于控制缓冲区的状态。

接下来，我们可以创建生产者和消费者线程，它们分别向缓冲区放入数据和取出数据：

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BoundedBuffer<Integer> buffer = new BoundedBuffer<>(10);

        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    buffer.put(i);
                    System.out.println("Produced: " + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 100; i++) {
                    int item = buffer.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

在这个示例中，生产者线程不断地向缓冲区放入数据，而消费者线程不断地从缓冲区取出数据，它们通过 await() 和 signal() 方法进行线程协作。

注意事项

在使用 Condition 接口时，需要注意以下几点：

1. 必须在获取锁之后才能调用 await()、signal() 和 signalAll() 方法，否则会抛出 IllegalMonitorStateException 异常。

2. 调用 await() 方法后，当前线程将释放锁，允许其他线程获取锁并执行。当线程被唤醒后，它将重新尝试获取锁，然后从 await() 方法返回。

3. signal() 方法只能唤醒一个等待线程，如果有多个线程在等待，具体唤醒哪一个是不确定的。如果需要唤醒所有等待线程，可以使用 signalAll() 方法。

4. 在等待时，通常需要将 await() 方法包装在一个循环中，以防止虚假唤醒。

5. 使用 Condition 接口时，要特别小心死锁和竞态条件等多线程问题，确保线程协作的正确性和安全性。

总结

Condition 接口提供了一种更灵活和高级的线程协作机制，可以用于实现复杂的线程同步和通信。通过创建多个条件对象，你可以更精细地控制线程的等待和唤醒。但在使用时需要小心处理锁和条件的关系，以确保线程协作的正确性和可靠性。希望本文对你理解和应用 Condition 接口有所帮助，提高多线程编程的技能。