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();
                }

            }



        }
    }

}

很顯然，使用阻塞佇列 實現無需單獨考慮同步和執行緒間通訊的問題，其實現起來很簡單。