生产者消费者模型

经典模式

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

public class ClassicMode {

    //TODO: 使用Object.wait()和Object.notify()以及非阻塞队列实现生产者和消费者模式
    private int queueSize = 10;
    private PriorityQueue<Integer> queue = new PriorityQueue<>(queueSize);

    public static void main(String[] args) {
        ClassicMode test = new ClassicMode();
        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 BlockingQueueMode {

    private int queueSize = 10;
    private ArrayBlockingQueue<Integer> que = new ArrayBlockingQueue<>(queueSize);

    public static void main(String[] args) {
        BlockingQueueMode test = new BlockingQueueMode();
        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 {
                    que.take();
                    System.out.println("从队列取走一个元素，队列剩余"+que.size()+"个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Producer extends Thread {

        @Override
        public void run() {
            produce();
        }

        private void produce() {

            while (true) {
                try {
                    que.put(1);
                    System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-que.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}