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

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