生产者与消费者模式

  1 准确说应该是生产者(setter)-消费者(getter)-仓储模型，离开了仓储，生产者消费者模型就显得没有说服
  2                  力了。
  3         >实现代码：
  4
  5             //1. 实体设计：同步栈仓储，共享数据域
  6             class SyncStack{
  7
  8                 //同步栈仓储中的数据产品，默认为10个大小
  9                 private String[] products=new String[10];
 10                 //数据产品数据的下标索引，初始化为0
 11                 private int index=0;
 12
 13                 //setter,方法名为push，压栈
 14                 //同步保证了只有对象只有一个线程占用
 15                 public synchronized void push(String sst){
 16                     //如果数据数组的下标递增到10(产品数据中的默认大小)
 17                     if(index==procucts.length){
 18                         try{
 19                             //线程阻塞，等待唤醒，释放自己的锁，使其他线程有机会获得
 20                             //对象的锁
 21                             wait();
 22                         }catch(InterruptedException e){
 23                             //打印错误踪迹
 24                             e.printStackTrace();
 25                         }
 26                     }
 27                     //当数组还未满10个对象时，唤醒在此监视器上等待的单个线程
 28                     this.notify();
 29                     //设值
 30                     products[index]=sst;
 31
 32                     index++;
 33                 }
 34
 35                 //getter，方法名为getPro,获取产品数组
 36                 public String[] getPro(){
 37                     return this.products;
 38                 }
 39
 40                 //delete，方法名为pop,弹栈
 41                 public String pop(){
 42                     if(index==0){
 43                         try{
 44                             wait();
 45                         }catch(InterruptedException e){
 46                             e.printStackTrace();
 47                         }
 48
 49                     }
 50                     this.notify();
 51                     //获取栈顶的元素
 52                     String product=products[index];
 53                     index--;
 54                     return product;
 55                 }
 56
 57             }
 58
 59             //2. 实体设计：生产者
 60             class Producer implements Runnable{
 61
 62                 //依赖同步栈的数据域
 63                 private SyncStack stack;
 64                 //setter，用构造函数进行设置值
 65                 public Producer(SyncStack stack){
 66                     this.stack=stack;
 67                 }
 68
 69                 //覆写运行的方法
 70                 public void run(){
 71                     //循环的往数据域里塞值
 72                     for(int i=0;i<stack.getPro().length;i++){
 73                         String product="产品"+i;
 74                         stack.push(product);
 75                         syso("生产了"+product);
 76                     }
 77                     try{
 78                         //线程睡眠1秒
 79                         Thread.sleep(1000);
 80                     }catch(InterruptedExcetion e){
 81                         e.printStackTrace();
 82                     }
 83
 84                 }
 85             }
 86
 87             //3. 实体设计：消费者
 88             classs Consumer implements Runnable{
 89
 90                 //依赖同步栈的数据域
 91                 private SyncStack stack;
 92                 //setter，用构造函数进行设置值
 93                 public Consumer(SyncStack stack){
 94                     this.stack=stack;
 95                 }
 96
 97                 //覆写运行的方法
 98                 public void run(){
 99                     //循环的在数据域弹值
100                     for(int i=0;i<stack.getPro().length;i++){
101                         String product=stack.pop();
102                         syso("消费了"+product);
103                     }
104                     try{
105                         //线程睡眠1秒
106                         Thread.sleep(1000);
107                     }catch(InterruptedExcetion e){
108                         e.printStackTrace();
109                     }
110             }
111
112
113             //4. 主方法，轮片调用生产者和消费者线程
114             public class ProCon{
115
116                 //创建数据共享域，即数据的仓储
117                 SyncStack stack=new SynnStack();
118
119                 //以同步栈即共享数据的仓储为参数创建生产者
120                 Producer producer=new Producer(stack);
121                 //以同步栈即共享数据的仓储为参数创建消费者
122                 Consumer consuner=new Consumer(stack);
123
124                 //创建生产者线程之后使线程为就绪状态
125                 new Thread(producer).start();
126                 //创建消费者之后使线程为就绪状态
127                 new Thread(consumer).start();
128             }