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. }

你可能感兴趣的:(Java,线程)