生产者消费者

生产面包、消费面包

运用了线程锁来锁定容器，保证生产和消费过程中不冲突。

使用wait和notify来提示其他线程

生产速度=消费速度*2，所以在生产结束后，生产线程停止，消费剩余面包后，通知不到生产线程，程序不停止（）

  1 package ProducerConsumer;
  2 
  3 import java.lang.Thread.State;
  4 import java.util.Random;
  5 
  6 public class App {
  7 
  8     public static void main(String[] args) {
  9         // TODO Auto-generated method stub
 10         SyncStack stack=new SyncStack();
 11         Proc proc=new Proc(stack);
 12         Cons cons=new Cons(stack);
 13         new Thread(proc).start();
 14         new Thread(cons).start();
 15     }
 16 
 17 }
 18 
 19 class Bread{
 20     int id;
 21 
 22     public Bread(int id) {
 23         super();
 24         this.id = id;
 25     }
 26 
 27     @Override
 28     public String toString() {
 29         return "面包"+id;
 30     }
 31 }
 32 
 33 
 34 //容器
 35 class SyncStack{
 36     int index=0;
 37     Bread[]breads = new Bread[20];
 38     
 39     //生产
 40     public synchronized void put(Bread bread){
 41         while(index==breads.length){
 42             System.out.println("装满了，等待消费。。。");
 43             try {
 44                 this.wait();
 45             } catch (InterruptedException e) {
 46                 // TODO Auto-generated catch block
 47                 e.printStackTrace();
 48             }
 49         }
 50         this.notify();
 51         this.breads[index]=bread;
 52         index++;
 53     }
 54     
 55     //消费
 56     public synchronized Bread get(){
 57         while(index==0){
 58             System.out.println("空了，等待生产。。。");
 59             try {
 60                 this.wait();
 61             } catch (InterruptedException e) {
 62                 // TODO Auto-generated catch block
 63                 e.printStackTrace();
 64             }
 65         }
 66         this.notify();
 67         index--;
 68         return breads[index];
 69     }
 70 }
 71 
 72 
 73 class Proc implements Runnable{
 74 
 75     SyncStack stack=null;
 76     
 77     public  Proc(SyncStack stack) {
 78         // TODO Auto-generated constructor stub
 79         this.stack=stack;
 80     }
 81     
 82     @Override
 83     public void run() {
 84         // TODO Auto-generated method stub
 85         for(int i=0;i<100;i++){
 86             Bread bread=new Bread(i);
 87             stack.put(bread);
 88             System.out.println("生成了:"+bread);
 89             try {
 90                 Thread.sleep(new Random().nextInt(5)*1000);
 91             } catch (InterruptedException e) {
 92                 // TODO Auto-generated catch block
 93                 e.printStackTrace();
 94             }
 95         }
 96     }
 97 }
 98 
 99 
100 class Cons implements Runnable{
101     SyncStack stack;
102 
103     public Cons(SyncStack stack) {
104         this.stack = stack;
105     }
106 
107     @Override
108     public void run() {
109         // TODO Auto-generated method stub
110         while(true){
111             Bread bread=stack.get();
112             System.out.println("消费了:"+bread);
113             try {
114                 Thread.sleep(new Random().nextInt(5)*2000);
115             } catch (InterruptedException e) {
116                 // TODO Auto-generated catch block
117                 e.printStackTrace();
118             }
119         }
120     }
121 }

 

posted @ 2019-05-17 19:40  人类一思考上帝就发笑  阅读(235)  评论(0)  编辑  收藏  举报