aqs 条件队列和同步队列、独占模式和共享模式

Tsbug

已于 2024-04-24 19:44:23 修改

阅读量206

点赞数 3

文章标签： java 开发语言

于 2024-04-24 19:19:07 首次发布

本文链接：https://blog.csdn.net/Tsbug/article/details/138167421

版权

本文详细介绍了使用Java的ReentrantLock和Condition接口实现的生产者-消费者模型，展示了如何在同步队列（如LinkedList）中使用条件队列进行同步，确保生产者和消费者之间的协作有效。

摘要由CSDN通过智能技术生成

同步/条件队列

先上代码

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

public class ProducerConsumerExample {
    private static final int CAPACITY = 5;
    private final Queue<Integer> queue = new LinkedList<>();
    private final ReentrantLock lock = new ReentrantLock(true);
    private final Condition bufferNotFull = lock.newCondition();
    private final Condition bufferNotEmpty = lock.newCondition();

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            lock.lock();
            try {
                while (queue.size() == CAPACITY) {
                    System.out.println("Buffer is full, waiting...");
                    bufferNotFull.await(); // 等待，直到缓冲区不满
                }
                queue.add(value);
                System.out.println("Produced: " + value);
                value++;
                bufferNotEmpty.signal(); // 通知消费者缓冲区有数据了
            } finally {
                lock.unlock();
            }
            Thread.sleep(1000); // 模拟生产时间
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            lock.lock();
            try {
                while (queue.isEmpty()) {
                    System.out.println("Buffer is empty, waiting...");
                    bufferNotEmpty.await(); // 等待，直到缓冲区不为空
                }
                int value = queue.poll();
                System.out.println("Consumed: " + value);
                bufferNotFull.signal(); // 通知生产者缓冲区不满了
            } finally {
                lock.unlock();
            }
            Thread.sleep(1000); // 模拟消费时间
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producerThread = new Thread(() -> {
            try {
                example.produce();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                example.consume();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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