生产者消费者模型

最新推荐文章于 2025-05-26 14:52:34 发布

原创最新推荐文章于 2025-05-26 14:52:34 发布 · 133 阅读

0 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

9 篇文章

订阅专栏

本文通过Java代码详细展示了生产者消费者模式的实现过程，利用了PriorityQueue作为共享资源，ReentrantLock进行线程同步，以及Condition来控制生产者和消费者的等待和唤醒。此模式有效地解决了多线程间的资源竞争问题。

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

/**
 * @Author dfpeng
 * @Date 2019/7/8
 */
public class ProducerConsumer {
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<>(queueSize);
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {
        ProducerConsumer pc = new ProducerConsumer();
        Producer p = pc.new Producer();
        Consumer c = pc.new Consumer();
        p.start();
        c.start();
        Thread.sleep(0);
        p.interrupt();
        c.interrupt();
    }

    class Consumer extends Thread {
        @Override
        public void run() {
            consume();
        }

        volatile boolean flag = true;

        private void consume() {
            while (flag) {
                lock.lock();
                try {
                    while (queue.isEmpty()) {
                        try {
                            System.out.println("队列空，等待数据");
                            //等待队列不为空
                            notEmpty.await();
                        } catch (InterruptedException e) {
//                            e.printStackTrace();
                            flag = false;
                        }
                    }
                    //每次移走队首元素
                    queue.poll();
                    notFull.signal();
                    System.out.println("从队列取走一个元素，队列剩余" + queue.size() + "个元素");
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    class Producer extends Thread {
        @Override
        public void run() {
            produce();
        }

        volatile boolean flag = true;

        private void produce() {
            while (flag) {
                lock.lock();
                try {
                    while (queue.size() == queueSize) {
                        try {
                            System.out.println("队列满，等待有剩余空间");
                            notFull.await();
                        } catch (InterruptedException e) {
//                            e.printStackTrace();
                            flag = false;
                        }
                    }
                    queue.offer(1);
                    notEmpty.signal();
                    System.out.println("向队列中插入一个元素，队列剩余空间：" + (queueSize - queue.size()));
                } finally {
                    lock.unlock();
                }
            }
        }
    }
}