多线程程序设计学习（6）Producer-Consumer模式

 1 package com.yeepay.sxf.thread5;
 2 /**
 3  * 在消费线程和生产线程中间起传递作用的桌子
 4  * @author sxf
 5  *
 6  */
 7 
 8 public class Table {
 9     //存放蛋糕的数组
10     private String[] cakes;
11     //下一个放蛋糕的位置
12     private int nextPut;
13     //下一个取蛋糕的位置
14     private int nextGet;
15     //蛋糕数组中蛋糕的数量
16     private int count;
17     //构造器
18     public Table (int count){
19         this.cakes=new String[count];
20         this.nextGet=0;
21         this.nextPut=0;
22     }
23     //存放蛋糕
24     public synchronized  void putCakes(String cake) throws InterruptedException{
25         System.out.println("["+Thread.currentThread().getName()+"]put"+cake);
26         //警戒条件  如果桌子上蛋糕，慢了，就阻塞生产线程。
27         while (count>=cakes.length) {
28             wait();            
29         }
30         //将蛋糕放入模拟队列
31         cakes[nextPut]=cake;
32         //算出下一个放蛋糕的位置
33         nextPut=(nextPut+1)%cakes.length;
34         //蛋糕数据量加1
35         count++;
36         //唤醒别的线程
37         notifyAll();
38     }
39     
40     //取蛋糕
41     public synchronized String takeCake() throws InterruptedException{
42         //判断桌子上是否有蛋糕,如果没有，阻塞线程
43         while (count<=0) {
44             wait();
45         }
46         //取出蛋糕
47         String cake=cakes[nextGet];
48         //计算出下一个取蛋糕的位置
49         nextGet=(nextGet+1)%cakes.length;
50         //蛋糕数量减一
51         count--;
52         //唤醒其他线程
53         notifyAll();
54         System.out.println("【"+Thread.currentThread().getName()+"】get"+cake);
55         return cake;
56     }
57 }

 1 package com.yeepay.sxf.thread5;
 2 /**
 3  * 制造蛋糕线程
 4  * @author sxf
 5  *
 6  */
 7 public class MakeCakeThread implements Runnable{
 8     //存放蛋糕的桌子
 9     private Table table;
10     
11     //构造器
12     public  MakeCakeThread(Table table) {
13         this.table=table;
14     }
15 
16     @Override
17     public void run() {
18         while (true) {
19             for (int i = 0; i <100; i++) {
20                 
21                 try {
22                     //生产蛋糕，并放入
23                     table.putCakes(Thread.currentThread().getName()+"的蛋糕"+i);
24                     //当前线程休息1秒钟
25                 
26                     Thread.sleep(1000);
27                 } catch (InterruptedException e) {
28                     // TODO Auto-generated catch block
29                     e.printStackTrace();
30                 }
31             }
32             
33         }
34         
35     }
36 
37     
38 }

 1 package com.yeepay.sxf.thread5;
 2 /**
 3  * 吃蛋糕的线程
 4  * @author sxf
 5  *
 6  */
 7 public class EatCakeThread implements Runnable {
 8     //桌子
 9     private  Table table;
10     //构造器
11     public EatCakeThread(Table table){
12         this.table=table;
13     }
14     /**
15      * 线程体
16      */
17     @Override
18     public void run() {
19         while(true){
20             try {
21                 String cake=table.takeCake();
22                 Thread.sleep(500);
23             } catch (InterruptedException e) {
24                 // TODO Auto-generated catch block
25                 e.printStackTrace();
26             }
27         }
28         
29     }
30     
31 }

 1 package com.yeepay.sxf.thread5;
 2 /**
 3  * 测试类
 4  * @author sxf
 5  *
 6  */
 7 public class Test {
 8 
 9     public static void main(String[] args) {
10         //声明一张桌子
11         Table table=new Table(4);
12         //声明生产蛋糕的线程
13         Thread makeThread1=new Thread(new MakeCakeThread(table));
14         makeThread1.setName("尚晓飞师傅");
15         Thread makeThread2=new Thread(new MakeCakeThread(table));
16         makeThread2.setName("范林军师傅");
17         Thread makeThread3=new Thread(new MakeCakeThread(table));
18         makeThread3.setName("黄栓林师傅");
19         
20         //声明吃蛋糕的线程
21         Thread eatThread1=new Thread(new EatCakeThread(table));
22         eatThread1.setName("顾客1");
23         Thread eatThread2=new Thread(new EatCakeThread(table));
24         eatThread2.setName("顾客2");
25         Thread eatThread3=new Thread(new EatCakeThread(table));
26         eatThread3.setName("顾客3");
27         
28         //启动线程
29         makeThread1.start();
30         makeThread2.start();
31         makeThread3.start();
32         eatThread1.start();
33         eatThread2.start();
34         eatThread3.start();
35         
36         
37     }
38 }