1 /**
  2  * 基于wait-notify机制的单生产者-消费者模型
  3  */
  4 public class ProducerAndConsumer {
  5
  6     public static void main(String[] args) {
  7         Resource resource = new Resource();
  8         //生产者线程
  9         ProducerThread p1 = new ProducerThread(resource);
 10         //消费者线程
 11         ConsumerThread c1 = new ConsumerThread(resource);
 12
 13         p1.start();
 14         c1.start();
 15
 16     }
 17 }
 18
 19
 20 /**
 21  * 公共资源类
 22  * @author
 23  *
 24  */
 25 class Resource{//重要
 26     //当前资源数量
 27     private int num = 0;
 28     //资源池中允许存放的资源数目
 29     private int size = 10;
 30
 31     /**
 32      * 从资源池中取走资源
 33      */
 34     public synchronized void remove(){
 35         if(num > 0){
 36             num--;
 37             System.out.println("消费者" + Thread.currentThread().getName() +
 38                     "消耗一件资源，" + "当前线程池有" + num + "个");
 39             notifyAll();//通知生产者生产资源
 40         }else{
 41             try {
 42                 //如果没有资源，则消费者进入等待状态
 43                 wait();
 44                 System.out.println("消费者" + Thread.currentThread().getName() + "线程进入等待状态");
 45             } catch (InterruptedException e) {
 46                 e.printStackTrace();
 47             }
 48         }
 49     }
 50     /**
 51      * 向资源池中添加资源
 52      */
 53     public synchronized void add(){
 54         if(num < size){
 55             num++;
 56             System.out.println("生产者" + Thread.currentThread().getName() + "生产一件资源，当前资源池有"
 57                     + num + "个");
 58             //通知等待的消费者
 59             notifyAll();
 60         }else{
 61             //如果当前资源池中有10件资源
 62             try{
 63                 wait();//生产者进入等待状态，并释放锁
 64                 System.out.println(Thread.currentThread().getName()+"线程进入等待");
 65             }catch(InterruptedException e){
 66                 e.printStackTrace();
 67             }
 68         }
 69     }
 70 }
 71
 72
 73 /**
 74  * 消费者线程
 75  */
 76 class ConsumerThread extends Thread{
 77     private Resource resource;
 78     public ConsumerThread(Resource resource){
 79         this.resource = resource;
 80     }
 81     @Override
 82     public void run() {
 83         while(true){
 84             try {
 85                 Thread.sleep(1000);
 86             } catch (InterruptedException e) {
 87                 e.printStackTrace();
 88             }
 89             resource.remove();
 90         }
 91     }
 92 }
 93
 94
 95 /**
 96  * 生产者线程
 97  */
 98 class ProducerThread extends Thread{
 99     private Resource resource;
100     public ProducerThread(Resource resource){
101         this.resource = resource;
102     }
103     @Override
104     public void run() {
105         //不断地生产资源
106         while(true){
107             try {
108                 Thread.sleep(1000);
109             } catch (InterruptedException e) {
110                 e.printStackTrace();
111             }
112             resource.add();
113         }
114     }
115
116 }