Java实现生产者消费者模式的两种方法

1、 利用 Object的 wait/notify，和非阻塞队列实现

import java.util.PriorityQueue;



public class Test{


    private int size=10;
    private PriorityQueue<Integer> queue=new PriorityQueue<>(size);


    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() {
            // TODO Auto-generated method stub


            while (true) {
                synchronized (queue) {

                    while (queue.size()==0) {


                        try {
                            System.out.println("队列空  等待数据");
                            queue.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                            queue.notify();
                        }

                    }




                    queue.poll();

                    queue.notify();
                }

            }



        }
    }


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


            while (true) {

                synchronized (queue) {
                    while (queue.size()==size) {

                        try {

                            System.out.println("队列满  等待有空余空间");
                            queue.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                            queue.notify();
                        }

                    }




                    queue.offer(1);
                    queue.notify();

                }

            }

        }
    }




}

2、 利用 阻塞队列实现

import java.util.concurrent.ArrayBlockingQueue;

public class Test {

    private int size=10;

    private ArrayBlockingQueue<Integer> queue=new ArrayBlockingQueue<>(size);

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        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() {
            // TODO Auto-generated method stub


            while (true) {

                try {
                    queue.take();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }


        }
    }



    class Producer extends Thread{
        @Override
        public void run() {
            // TODO Auto-generated method stub



            while (true) {
                try {
                    queue.put(1);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }



        }
    }

}

很显然，使用阻塞队列 实现无需单独考虑同步和线程间通信的问题，其实现起来很简单。