资源同步与互斥问题（生产者与消费者）





源码：

package hsx.test;

public class Sample {
 
 public static void main(String[] args) {
  BreadContainer bc = new BreadContainer(50);
  Producer producer1 = new Producer(bc, 50, "producer1");
  Producer producer2 = new Producer(bc, 200, "producer2");
  Consumer consumer1 = new Consumer(bc, 290, "consumer1");
  Consumer consumer2 = new Consumer(bc, 70, "consumer2");
  Consumer consumer3 = new Consumer(bc, 80, "consumer3");
  consumer1.start();
  consumer2.start();
  producer1.start();
  producer2.start();
  consumer3.start();
 }
}

class BreadContainer {
 public static final int MAXNUM = 300;
 private int num = 0;
 public BreadContainer(int num) {
  this.num = num;
 }
 public synchronized void produceBread(String produceName, int produceNum) {
  while(num + produceNum > MAXNUM) {
   System.out.println("要生产的量加上原有的量超过了容器的量，所以" + produceName + "等待消费者消费部分,满足再生产。");
   try {
    wait();
   }
   catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  num += produceNum;
  System.out.println(produceName + "生产了" + produceNum + "个，现在一共有" + num + "个。");
  notifyAll();
 }
 public synchronized void consumeBread(String consumeName, int consumeNum) {
  while(consumeNum > num) {
   System.out.println("要消费的量超过了容器的总量，所以" + consumeName + "等待生产者生产部分，满足再消费。");
   try {
    wait();
   }
   catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
  num -= consumeNum;
  System.out.println(consumeName + "消费了" + consumeNum + "个，现在一共有" + num + "个。");
  notifyAll();
 }
}

class Producer extends Thread {
 private BreadContainer bc = null;
 private int produceNum = 0;
 public Producer(BreadContainer bc, int produceNum, String ProduceName) {
  this.bc = bc;
  this.produceNum = produceNum;
  this.setName(ProduceName);
 }
 @Override
 public void run() {
  bc.produceBread(this.getName(), produceNum);
 }
}

class Consumer extends Thread {
 private BreadContainer bc = null;
 private int consumeNum = 0;
 public Consumer(BreadContainer bc, int consumeNum, String consumeName) {
  this.bc = bc;
  this.consumeNum = consumeNum;
  this.setName(consumeName);
 }
 @Override
 public void run() {
  bc.consumeBread(this.getName(), consumeNum);
 }
}

显示结果：

要消费的量超过了容器的总量，所以consumer1等待生产者生产部分，满足再消费。
要消费的量超过了容器的总量，所以consumer2等待生产者生产部分，满足再消费。
producer1生产了50个，现在一共有100个。
consumer2消费了70个，现在一共有30个。
要消费的量超过了容器的总量，所以consumer1等待生产者生产部分，满足再消费。
producer2生产了200个，现在一共有230个。
要消费的量超过了容器的总量，所以consumer1等待生产者生产部分，满足再消费。
consumer3消费了80个，现在一共有150个。
要消费的量超过了容器的总量，所以consumer1等待生产者生产部分，满足再消费。