生产者消费者问题

Myth丶恋晨 2022-07-17 02:37 224阅读 0赞

使用Object.wait()和Object.notify()、非阻塞队列实现生产者-消费者模式：

public class Test {
        private int queueSize = 10;
        private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
         
        public static void main(String[] args)  {
            Test test = new Test();
            Producer producer = test.new Producer();
            Consumer consumer = test.new Consumer();
             
            producer.start();
            consumer.start();
        }
         
        class Consumer extends Thread{
             
            @Override
            public void run() {
                consume();
            }
             
            private void consume() {
                while(true){
                    synchronized (queue) {
                        while(queue.size() == 0){
                            try {
                                System.out.println("队列空，等待数据");
                                queue.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                                queue.notify();
                            }
                        }
                        queue.poll();          //每次移走队首元素
                        queue.notify();
                        System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                    }
                }
            }
        }
         
        class Producer extends Thread{
             
            @Override
            public void run() {
                produce();
            }
             
            private void produce() {
                while(true){
                    synchronized (queue) {
                        while(queue.size() == queueSize){
                            try {
                                System.out.println("队列满，等待有空余空间");
                                queue.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                                queue.notify();
                            }
                        }
                        queue.offer(1);        //每次插入一个元素
                        queue.notify();
                        System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                    }
                }
            }
        }
    }

使用阻塞队列实现的生产者-消费者模式：

public class Test {
        private int queueSize = 10;
        private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(queueSize);
         
        public static void main(String[] args)  {
            Test test = new Test();
            Producer producer = test.new Producer();
            Consumer consumer = test.new Consumer();
             
            producer.start();
            consumer.start();
        }
         
        class Consumer extends Thread{
             
            @Override
            public void run() {
                consume();
            }
             
            private void consume() {
                while(true){
                    try {
                        queue.take();
                        System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
         
        class Producer extends Thread{
             
            @Override
            public void run() {
                produce();
            }
             
            private void produce() {
                while(true){
                    try {
                        queue.put(1);
                        System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }