Java 生产者-消费者案例框架

[color=olive][b]“生产者-消费者”问题的含义是，系统中有很多生产者和消费者并发工作生产者负责生产资源，消费者消耗资源。当消费者消费资源时，如果资源不足，则需要等待，反之当生产者生产资源时，若资源已满，则也需要等待。另外同一时刻只能有一个生产者或消费者进行操作。[/b][/color]

//面包容器（资源）   
class BreadContainer {
	// 容器的最大容量
	public static final int maxNum = 300;
	// 当前面包的数量
	private int num;

	// 无参构造器
	public BreadContainer() {
	}

	// 有参构造器
	public BreadContainer(int num) {
		// 初始化面包数量
		this.num = num;
	}

	// 制作面包的同步方法
	public synchronized void produceBread(int produceNum, String producerName) {
		// 测试是否可以生产面包
		while (num + produceNum > maxNum) {
			// 面包充足，生产者等待
			System.out.println(producerName + "要生产" + produceNum + "个，当前" + num
					+ "个，资源充足，不需要生产，" + producerName + "去等待！");
			try {
				wait();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		// 满足条件后，生产者生产面包，刷新数量
		num = num + produceNum;
		System.out.println(producerName + "生产了" + produceNum + "个，现在有" + num
				+ "个。");
		// 唤醒资源等待池中的所有线程
		notifyAll();
	}

	public synchronized void consumeBread(int consumeNum, String consumerName) {
		// 测试面包数量是否够消费
		while (consumeNum > num) {
			// 不够数量，消费者等待
			System.out.println(consumerName + "要消费" + consumeNum + "个，由于现在只有"
					+ num + "个，" + consumerName + "于是去等待！");
			try {
				wait();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		// 数量充足，消费面包，刷新数量
		num = num - consumeNum;
		System.out.println(consumerName + "消费了" + consumeNum + "个，现在还剩下" + num
				+ "个");
		// 唤醒资源等待池中的所有线程
		this.notifyAll();
	}
}

// 生产者类
class Producer extends Thread {
	// 记录该生产者一次生产的数量
	private int produceNum;
	// 生产者需要访问的面包容器资源
	private BreadContainer bc;

	// 无参构造器
	public Producer() {
	}

	// 有参构造器
	public Producer(int produceNum, BreadContainer bc, String producerName) {
		// 对线程进行初始化
		this.produceNum = produceNum;
		this.bc = bc;
		this.setName(producerName);
	}

	// 生产者的工作方法
	public void run() {
		// 调用资源容器的同步方法生产资源
		bc.produceBread(produceNum, this.getName());
	}
}

// 消费者类
class Consumer extends Thread {
	// 记录该消费者一次消费的数量
	private int consumeNum;
	// 消费者需要访问的面包容器资源
	private BreadContainer bc;

	// 无参构造器
	public Consumer() {
	}

	// 有参构造器
	public Consumer(int consumeNum, BreadContainer bc, String consumerName) {
		// 对线程进行初始化
		this.consumeNum = consumeNum;
		this.bc = bc;
		this.setName(consumerName);
	}

	// 消费者的行为方法
	public void run() {
		// 调用资源容器的同步方法生产资源
		bc.consumeBread(consumeNum, this.getName());
	}
}

public class Sample16_9 {
	public static void main(String args[]) {
		// 创建资源对象，初始面包有50个
		BreadContainer bc = new BreadContainer(50);
		// 创建对应的生产者和消费者
		Producer p1 = new Producer(50, bc, "P1");
		Producer p2 = new Producer(200, bc, "P2");
		Producer p3 = new Producer(290, bc, "P3");
		Consumer c1 = new Consumer(70, bc, "c1");
		Consumer c2 = new Consumer(80, bc, "c2");
		// 启动生产者消费者线程
		c1.start();
		c2.start();
		p1.start();
		p3.start();
		p2.start();
	}
}