在Java中如何使用Lock和Condition实现生产者消费者模型_LockCondition生产者消费者操作解析

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> queue = new LinkedList<>();
    private final int MAX_SIZE = 5;
    
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public void produce(int item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == MAX_SIZE) {
                System.out.println("队列已满，生产者等待...");
                notFull.await(); // 等待不满信号
            }
            queue.offer(item);
            System.out.println("生产了：" + item + "，当前大小：" + queue.size());
            notEmpty.signal(); // 唤醒消费者
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                System.out.println("队列为空，消费者等待...");
                notEmpty.await(); // 等待不空信号
            }
            int item = queue.poll();
            System.out.println("消费了：" + item + "，剩余大小：" + queue.size());
            notFull.signal(); // 唤醒生产者
            return item;
        } finally {
            lock.unlock();
        }
    }
}

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

    // 生产者线程
    new Thread(() -> {
        int i = 0;
        while (true) {
            try {
                pc.produce(++i);
                Thread.sleep(500);
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }
    }).start();

    // 消费者线程
    new Thread(() -> {
        while (true) {
            try {
                pc.consume();
                Thread.sleep(800);
            } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        }
    }).start();
}