1 package unit;
 2 
 3 import java.util.PriorityQueue;
 4 
 5 /**
 6  * 非阻塞隊列
 7  * @author 54304
 8  *
 9  */
10 public class BlockingQueue {
11     private int queueSize = 10;
12     private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
13      
14     public static
 
 void main(String[] args)  {
15         BlockingQueue test = new BlockingQueue();
16         Producer producer = test.new Producer();
17         Consumer consumer = test.new Consumer();
18          
19         producer.start();
20         consumer.start();
21     }
22      
23     class Consumer extends
 
 Thread{
24          
25         @Override
26         public void run() {
27             consume();
28         }
29          
30         private void consume() {
31             while(true){
32                 synchronized (queue) {
33                     while(queue.size() == 0){
34                         try
 
 {
35                             System.out.println("隊列空，等待數據");
36                             queue.wait();
37                         } catch (InterruptedException e) {
38                             e.printStackTrace();
39                             queue.notify();
40                         }
41                     }
42                     queue.poll();          //每次移走隊首元素
43                     queue.notify();
44                     System.out.println("從隊列取走一個元素，隊列剩余"+queue.size()+"個元素");
45                 }
46             }
47         }
48     }
49      
50     class Producer extends Thread{
51          
52         @Override
53         public void run() {
54             produce();
55         }
56          
57         private void produce() {
58             while(true){
59                 synchronized (queue) {
60                     while(queue.size() == queueSize){
61                         try {
62                             System.out.println("隊列滿，等待有空余空間");
63                             queue.wait();
64                         } catch (InterruptedException e) {
65                             e.printStackTrace();
66                             queue.notify();
67                         }
68                     }
69                     queue.offer(1);        //每次插入一個元素
70                     queue.notify();
71                     System.out.println("向隊列取中插入一個元素，隊列剩余空間："+(queueSize-queue.size()));
72                 }
73             }
74         }
75     }
76 }

非阻塞隊列