【19】java多线程之生产者消费者经典问题

consumer和producer里面的线程休眠，一个10ms一个100ms只是为了让producer有更高概率获得对象锁，其实不写也线程休眠也可以。

1. package thread;    
2. public class ProduceConsume {  
3.   
4.     public static void main(String[] args) {  
5.         SyncStack ss = new SyncStack();
6.         Producer p = new Producer(ss);
7.         Consume c = new Consume(ss);
8.         Thread tp = new Thread(p);
9.         Thread tc = new Thread(c);
10.         tp.start();//启动生产者线程  
11.         tc.start();//启动消费者线程  
12.     }    
13. }  
14.   
15. class SteamBread{  
16.     int id;
17.     SteamBread(int id){  
18.         this.id = id;  
19.     }  
20.     public String toString(){  
21.         return "steamBread:"+id;  
22.     }  
23. }  
24.  
25. class SyncStack{  
26.     int index = 0;  
27.     SteamBread[] stb = new SteamBread[6];//构造馒头数组，相当于馒头筐，容量是6  
28.       
29.     //放入框中，相当于入栈  
30.     public synchronized void push(SteamBread sb){  
31.         while(index==stb.length){//筐满了，即栈满，  
32.             try {  
33.                 this.wait();//让当前线程等待  
34.             } catch (InterruptedException e) {  
35.                 // TODO Auto-generated catch block  
36.                 e.printStackTrace();  
37.             }  
38.         }  
39.         this.notify();//唤醒在此对象监视器上等待的单个线程，即消费者线程  
40.         stb[index] = sb;  
41.         this.index++;  
42.     }  
43.       
44.     //从框中拿出，相当于出栈  
45.     public synchronized SteamBread pop(){  
46.         while(index==0){//筐空了，即栈空  
47.             try {  
48.                 this.wait();  
49.             } catch (InterruptedException e) {  
50.                 // TODO Auto-generated catch block  
51.                 e.printStackTrace();  
52.             }  
53.         }  
54.         this.notify();  
55.         this.index--;//push第n个之后，this.index++，使栈顶为n+1，故return之前要减一  
56.         return stb[index];  
57.     }  
58. }  
59.   
60. //生产者类，实现了Runnable接口，以便于构造生产者线程  
61. class Producer implements Runnable{  
62.     SyncStack ss = null;  
63.     Producer(SyncStack ss){  
64.         this.ss = ss;  
65.     }  
66.     @Override  
67.     public void run() {  
68.         // 开始生产馒头  
69.         for(int i=0;i<20;i++){  
70.             SteamBread stb = new SteamBread(i);  
71.             ss.push(stb);  
72.             System.out.println("生产了"+stb);  
73.             try {  
74.                 Thread.sleep(10);//每生产一个馒头，睡觉10毫秒  
75.             } catch (InterruptedException e) {  
76.                 // TODO Auto-generated catch block  
77.                 e.printStackTrace();  
78.             }  
79.         }  
80.     }  
81. }  
82.   
83. //消费者类，实现了Runnable接口，以便于构造消费者线程  
84. class Consume implements Runnable{  
85.     SyncStack ss = null;  
86.     public Consume(SyncStack ss) {  
87.         super();  
88.         this.ss = ss;  
89.     }  
90.     @Override  
91.     public void run() {  
92.         // TODO Auto-generated method stub  
93.         for(int i=0;i<20;i++){//开始消费馒头  
94.             SteamBread stb = ss.pop();  
95.             System.out.println("消费了"+stb);  
96.             try {  
97.                 Thread.sleep(100);//每消费一个馒头，睡觉100毫秒。即生产多个，消费一个  
98.             } catch (InterruptedException e) {  
99.                 // TODO Auto-generated catch block  
100.                 e.printStackTrace();  
101.             }  
102.         }  
103.     }     
104. }

运行结果：