java多线程之消费者生产者模式

  1 /*@author shijin

  2 * 生产者与消费者模型中，要保证以下几点：

  3 * 1 同一时间内只能有一个生产者生产        生产方法加锁sychronized

  4 * 2 同一时间内只能有一个消费者消费        消费方法加锁sychronized

  5 * 3 生产者生产的同时消费者不能消费        生产方法加锁sychronized

  6 * 4 消费者消费的同时生产者不能生产        消费方法加锁sychronized

  7 * 5 共享空间空时消费者不能继续消费        消费前循环判断是否为空，空的话将该线程wait，释放锁允许其他同步方法执行

  8 * 6 共享空间满时生产者不能继续生产        生产前循环判断是否为满，满的话将该线程wait，释放锁允许其他同步方法执行   

  9 */

 10 

 11 //主类

 12 class  ProducerConsumer

 13 {

 14     public static void main(String[] args) 

 15     {

 16         StackBasket s = new StackBasket();

 17         Producer p = new Producer(s);

 18         Consumer c = new Consumer(s);

 19         Thread tp = new Thread(p);

 20         Thread tc = new Thread(c);

 21         tp.start();

 22         tc.start();

 23     }

 24 }

 25 

 26 //

 27 class Mantou

 28 {

 29     private int id;

 30     

 31     Mantou(int id){

 32         this.id = id;

 33     }

 34 

 35     public String toString(){

 36         return "Mantou :" + id;

 37     }

 38 }

 39 

 40 //共享栈空间

 41 class StackBasket

 42 {

 43     Mantou sm[] = new Mantou[6];

 44     int index = 0;

 45     

 46     /** 

 47     * show 生产方法.

 48     * show 该方法为同步方法，持有方法锁；

 49     * show 首先循环判断满否，满的话使该线程等待，释放同步方法锁，允许消费；

 50     * show 当不满时首先唤醒正在等待的消费方法，但是也只能让其进入就绪状态，

 51     * show 等生产结束释放同步方法锁后消费才能持有该锁进行消费

 52     * @param m 元素

 53     * @return 没有返回值 

 54     */ 

 55 

 56     public synchronized void push(Mantou m){

 57         try{

 58             while(index == sm.length){

 59                 System.out.println("!!!!!!!!!生产满了!!!!!!!!!");

 60                 this.wait();

 61             }

 62             this.notify();

 63         }catch(InterruptedException e){

 64             e.printStackTrace();

 65         }catch(IllegalMonitorStateException e){

 66             e.printStackTrace();

 67         }

 68         

 69         sm[index] = m;

 70         index++;

 71         System.out.println("生产了：" + m + " 共" + index + "个馒头");

 72     }

 73 

 74     /** 

 75     * show 消费方法

 76     * show 该方法为同步方法，持有方法锁

 77     * show 首先循环判断空否，空的话使该线程等待，释放同步方法锁，允许生产；

 78     * show 当不空时首先唤醒正在等待的生产方法，但是也只能让其进入就绪状态

 79     * show 等消费结束释放同步方法锁后生产才能持有该锁进行生产

 80     * @param b true 表示显示，false 表示隐藏 

 81     * @return 没有返回值 

 82     */ 

 83     public synchronized Mantou pop(){

 84         try{

 85             while(index == 0){

 86                 System.out.println("!!!!!!!!!消费光了!!!!!!!!!");

 87                 this.wait();

 88             }

 89             this.notify();

 90         }catch(InterruptedException e){

 91             e.printStackTrace();

 92         }catch(IllegalMonitorStateException e){

 93             e.printStackTrace();

 94         }

 95         index--;

 96         System.out.println("消费了：---------" + sm[index] + " 共" + index + "个馒头");

 97         return sm[index];

 98     }

 99 }

100 

101 class Producer implements Runnable

102 {

103     StackBasket ss = new StackBasket();

104     Producer(StackBasket ss){

105         this.ss = ss;

106     }

107 

108     /** 

109     * show 生产进程. 

110     */ 

111     public void run(){

112         for(int i = 0;i < 20;i++){

113             Mantou m = new Mantou(i);

114             ss.push(m);

115 //            System.out.println("生产了：" + m + " 共" + ss.index + "个馒头");

116 //            在上面一行进行测试是不妥的，对index的访问应该在原子操作里，因为可能在push之后此输出之前又消费了，会产生输出混乱

117             try{

118                 Thread.sleep((int)(Math.random()*500));

119             }catch(InterruptedException e){

120                 e.printStackTrace();

121             }

122         }

123     }

124 }

125 

126 class Consumer implements Runnable

127 {

128     StackBasket ss = new StackBasket();

129     Consumer(StackBasket ss){

130         this.ss = ss;

131     }

132 

133     /** 

134     * show 消费进程.

135     */ 

136     public void run(){

137         for(int i = 0;i < 20;i++){

138             Mantou m = ss.pop();

139 //            System.out.println("消费了：---------" + m + " 共" + ss.index + "个馒头");

140 //    同上    在上面一行进行测试也是不妥的，对index的访问应该在原子操作里，因为可能在pop之后此输出之前又生产了，会产生输出混乱

141             try{

142                 Thread.sleep((int)(Math.random()*1000));

143             }catch(InterruptedException e){

144                 e.printStackTrace();

145             }

146         }

147     }

148 }