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

/*@author shijin 
* 生产者与消费者模型中，要保证以下几点： 
* 1 同一时间内只能有一个生产者生产     生产方法加锁sychronized 
* 2 同一时间内只能有一个消费者消费     消费方法加锁sychronized 
* 3 生产者生产的同时消费者不能消费     生产方法加锁sychronized 
* 4 消费者消费的同时生产者不能生产     消费方法加锁sychronized 
* 5 共享空间空时消费者不能继续消费     消费前循环判断是否为空，空的话将该线程wait，释放锁允许其他同步方法执行 
* 6 共享空间满时生产者不能继续生产     生产前循环判断是否为满，满的话将该线程wait，释放锁允许其他同步方法执行    
*/  
  
//主类  
class  ProducerConsumer  
{  
    public static void main(String[] args)   
    {  
        StackBasket s = new StackBasket();  
        Producer p = new Producer(s);  
        Consumer c = new Consumer(s);  
        Thread tp = new Thread(p);  
        Thread tc = new Thread(c);  
        tp.start();  
        tc.start();  
    }  
}  
  
//  
class Mantou  
{  
    private int id;  
      
    Mantou(int id){  
        this.id = id;  
    }  
  
    public String toString(){  
        return "Mantou :" + id;  
    }  
}  
  
//共享栈空间  
class StackBasket  
{  
    Mantou sm[] = new Mantou[6];  
    int index = 0;  
      
    /**  
    * show 生产方法. 
    * show 该方法为同步方法，持有方法锁； 
    * show 首先循环判断满否，满的话使该线程等待，释放同步方法锁，允许消费； 
    * show 当不满时首先唤醒正在等待的消费方法，但是也只能让其进入就绪状态， 
    * show 等生产结束释放同步方法锁后消费才能持有该锁进行消费 
    * @param m 元素 
    * @return 没有返回值  
    */   
  
    public synchronized void push(Mantou m){  
        try{  
            while(index == sm.length){  
                System.out.println("!!!!!!!!!生产满了!!!!!!!!!");  
                this.wait();  
            }  
            this.notify();  
        }catch(InterruptedException e){  
            e.printStackTrace();  
        }catch(IllegalMonitorStateException e){  
            e.printStackTrace();  
        }  
          
        sm[index] = m;  
        index++;  
        System.out.println("生产了：" + m + " 共" + index + "个馒头");  
    }  
  
    /**  
    * show 消费方法 
    * show 该方法为同步方法，持有方法锁 
    * show 首先循环判断空否，空的话使该线程等待，释放同步方法锁，允许生产； 
    * show 当不空时首先唤醒正在等待的生产方法，但是也只能让其进入就绪状态 
    * show 等消费结束释放同步方法锁后生产才能持有该锁进行生产 
    * @param b true 表示显示，false 表示隐藏  
    * @return 没有返回值  
    */   
    public synchronized Mantou pop(){  
        try{  
            while(index == 0){  
                System.out.println("!!!!!!!!!消费光了!!!!!!!!!");  
                this.wait();  
            }  
            this.notify();  
        }catch(InterruptedException e){  
            e.printStackTrace();  
        }catch(IllegalMonitorStateException e){  
            e.printStackTrace();  
        }  
        index--;  
        System.out.println("消费了：---------" + sm[index] + " 共" + index + "个馒头");  
        return sm[index];  
    }  
}  
  
class Producer implements Runnable  
{  
    StackBasket ss = new StackBasket();  
    Producer(StackBasket ss){  
        this.ss = ss;  
    }  
  
    /**  
    * show 生产进程.  
    */   
    public void run(){  
        for(int i = 0;i < 20;i++){  
            Mantou m = new Mantou(i);  
            ss.push(m);  
//          System.out.println("生产了：" + m + " 共" + ss.index + "个馒头");  
//          在上面一行进行测试是不妥的，对index的访问应该在原子操作里，因为可能在push之后此输出之前又消费了，会产生输出混乱  
            try{  
                Thread.sleep((int)(Math.random()*500));  
            }catch(InterruptedException e){  
                e.printStackTrace();  
            }  
        }  
    }  
}  
  
class Consumer implements Runnable  
{  
    StackBasket ss = new StackBasket();  
    Consumer(StackBasket ss){  
        this.ss = ss;  
    }  
  
    /**  
    * show 消费进程. 
    */   
    public void run(){  
        for(int i = 0;i < 20;i++){  
            Mantou m = ss.pop();  
//          System.out.println("消费了：---------" + m + " 共" + ss.index + "个馒头");  
//  同上  在上面一行进行测试也是不妥的，对index的访问应该在原子操作里，因为可能在pop之后此输出之前又生产了，会产生输出混乱  
            try{  
                Thread.sleep((int)(Math.random()*1000));  
            }catch(InterruptedException e){  
                e.printStackTrace();  
            }  
        }  
    }  
}