Condition 的作用:

线程等待: 线程可以调用 await 方法进入等待状态，释放锁，并等待其他线程的通知。

线程通知: 线程可以调用 signal 或 signalAll 方法唤醒一个或所有正在等待的线程。

线程信号: 线程可以调用 signal 方法唤醒一个正在等待的线程，即使该线程尚未满足等待条件。

线程阻塞: 线程可以调用 await 方法进入等待状态，并阻塞当前线程，直到收到通知或超时。

Condition 与锁配合使用的原理:

创建锁实例: 创建一个锁实例，例如 ReentrantLock 或 Semaphore。

创建 Condition 实例: 调用锁实例的 newCondition 方法创建一个 Condition 实例。

线程等待: 线程调用 Condition 实例的 await 方法进入等待状态，释放锁，并等待其他线程的通知。

线程通知: 线程调用 Condition 实例的 signal 或 signalAll 方法唤醒一个或所有正在等待的线程。

线程信号: 线程调用 Condition 实例的 signal 方法唤醒一个正在等待的线程，即使该线程尚未满足等待条件。

线程阻塞: 线程调用 Condition 实例的 await 方法进入等待状态，并阻塞当前线程，直到收到通知或超时。

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

public class ProducerConsumerExample {
    private int count = 0;
    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 (count == 1) {
                notFull.await();
            }
            count++;
            System.out.println("Produced: " + value);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public void consume(int value) throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) {
                notEmpty.await();
            }
            count--;
            System.out.println("Consumed: " + value);
            notFull.signal();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    example.produce(i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    example.consume(i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

        producer.join();
        consumer.join();
    }
}