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



今天研究了一下java多线程，顺便写了一下多线程中的经典问题-----生产者消费者经典问题，参照了网上的各种写法之后自己写了一个，如下所示

[java] view plain copy print ?

1. <span style="font-size: 14px;">/**生产者消费者问题，涉及到几个类 
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. }</span>  

<span style="font-size: 14px;">/**生产者消费者问题，涉及到几个类
 * 第一，这个问题本身就是一个类，即主类
 * 第二，既然是生产者、消费者，那么生产者类和消费者类就是必须的
 * 第三，生产什么，消费什么，所以物品类是必须的，这里是馒头类
 * 第四，既然是线程，那么就不是一对一的，也就是说不是生产一个消费一个，既然这样，多生产的往哪里放，
 *      现实中就是筐了，在计算机中也就是数据结构，筐在数据结构中最形象的就是栈了，因此还要一个栈类
 */
package thread;

public class ProduceConsume {

	public static void main(String[] args) {
		SyncStack ss = new SyncStack();//建造一个装馒头的框
		Producer p = new Producer(ss);//新建一个生产者，使之持有框
		Consume c = new Consume(ss);//新建一个消费者，使之持有同一个框
		Thread tp = new Thread(p);//新建一个生产者线程
		Thread tc = new Thread(c);//新建一个消费者线程
		tp.start();//启动生产者线程
		tc.start();//启动消费者线程
	}

}

//馒头类
class SteamBread{
	int id;//馒头编号
	SteamBread(int id){
		this.id = id;
	}
	public String toString(){
		return "steamBread:"+id;
	}
}

//装馒头的框，栈结构
class SyncStack{
	int index = 0;
	SteamBread[] stb = new SteamBread[6];//构造馒头数组，相当于馒头筐，容量是6
	
	//放入框中，相当于入栈
	public synchronized void push(SteamBread sb){
		while(index==stb.length){//筐满了，即栈满，
			try {
				this.wait();//让当前线程等待
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.notify();//唤醒在此对象监视器上等待的单个线程，即消费者线程
		stb[index] = sb;
		this.index++;
	}
	
	//从框中拿出，相当于出栈
	public synchronized SteamBread pop(){
		while(index==0){//筐空了，即栈空
			try {
				this.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		this.notify();
		this.index--;//push第n个之后，this.index++，使栈顶为n+1，故return之前要减一
		return stb[index];
	}
}

//生产者类，实现了Runnable接口，以便于构造生产者线程
class Producer implements Runnable{
	SyncStack ss = null;
	Producer(SyncStack ss){
		this.ss = ss;
	}
	@Override
	public void run() {
		// 开始生产馒头
		for(int i=0;i<20;i++){
			SteamBread stb = new SteamBread(i);
			ss.push(stb);
			System.out.println("生产了"+stb);
			try {
				Thread.sleep(10);//每生产一个馒头，睡觉10毫秒
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

//消费者类，实现了Runnable接口，以便于构造消费者线程
class Consume implements Runnable{
	SyncStack ss = null;
	public Consume(SyncStack ss) {
		super();
		this.ss = ss;
	}
	@Override
	public void run() {
		// TODO Auto-generated method stub
		for(int i=0;i<20;i++){//开始消费馒头
			SteamBread stb = ss.pop();
			System.out.println("消费了"+stb);
			try {
				Thread.sleep(100);//每消费一个馒头，睡觉100毫秒。即生产多个，消费一个
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}	
}</span>

运行结果：