生产者和消费者模型都是所有多线程开发应用中一个最为经典的方法，下面我给大家整理了一个生产者和消费者模型的例子，供各位参考参考。

下面的代码讲述了一个故事

一个面包生产铺里目前有30个面包，有三个人来买面包，第一个人要买50个，第二个要买20个，第三个要买30个。

第一个人不够，所以等着，让第二个买了。面包铺继续生产面包。有7个人在生产。

代码如下

复制代码

package com.javaer.thread; public class CPMode { public static void main(String[] args) { Godown godown = new Godown(30); //初始化库存 30个食物 Consumer c1 = new Consumer(50, godown); Consumer c2 = new Consumer(20, godown); Consumer c3 = new Consumer(30, godown); Producer p1 = new Producer(10, godown); Producer p2 = new Producer(10, godown); Producer p3 = new Producer(10, godown); Producer p4 = new Producer(10, godown); Producer p5 = new Producer(10, godown); Producer p6 = new Producer(10, godown); Producer p7 = new Producer(80, godown); c1.start(); c2.start(); c3.start(); p1.start(); p2.start(); p3.start(); p4.start(); p5.start(); p6.start(); p7.start(); } } /** * 仓库 */ class Godown { public static final int max_size = 100; //最大库存量 public int curnum;     //当前库存量 Godown() { } Godown(int curnum) { this.curnum = curnum; } /** * 生产指定数量的产品 * * @param neednum */ public synchronized void produce(int neednum) { //测试是否需要生产 while (neednum curnum > max_size) { System.out.println("要生产的产品数量" neednum "超过剩余库存量" (max_size - curnum) "，暂时不能执行生产任务!"); try { //当前的生产线程等待 wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //满足生产条件，则进行生产，这里简单的更改当前库存量 curnum = neednum; System.out.println("已经生产了" neednum "个产品，现仓储量为" curnum); //唤醒在此对象监视器上等待的所有线程 notifyAll(); } /** * 消费指定数量的产品 * * @param neednum */ public synchronized void consume(int neednum) { //测试是否可消费 while (curnum < neednum) { try { //当前的消费线程等待 wait(); } catch (InterruptedException e) { e.printStackTrace(); } } //满足消费条件，则进行消费，这里简单的更改当前库存量 curnum -= neednum; System.out.println("已经消费了" neednum "个产品，现仓储量为" curnum); //唤醒在此对象监视器上等待的所有线程 notifyAll(); } } /** * 生产者 */ class Producer extends Thread { private int neednum;                //生产产品的数量 private Godown godown;            //仓库 Producer(int neednum, Godown godown) { this.neednum = neednum; this.godown = godown; } public void run() { //生产指定数量的产品 godown.produce(neednum); } } /** * 消费者 */ class Consumer extends Thread { private int neednum;                //生产产品的数量 private Godown godown;            //仓库 Consumer(int neednum, Godown godown) { this.neednum = neednum; this.godown = godown; } public void run() { //消费指定数量的产品 godown.consume(neednum); } } 已经消费了20个产品，现仓储量为10 已经生产了10个产品，现仓储量为20 已经生产了10个产品，现仓储量为30 已经生产了10个产品，现仓储量为40 已经生产了10个产品，现仓储量为50 已经消费了30个产品，现仓储量为20 已经生产了80个产品，现仓储量为100 已经消费了50个产品，现仓储量为50 已经生产了10个产品，现仓储量为60 已经生产了10个产品，现仓储量为70

注意：

实际上，准确说应该是“生产者-消费者-仓储”模型，离开了仓储，生产者消费者模型就显得没有说服力了。

对于此模型，应该明确一下几点：

1、生产者仅仅在仓储未满时候生产，仓满则停止生产。

2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。

3、当消费者发现仓储没产品可消费时候会通知生产者生产。

4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

例子二

package cn.thread;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingQueue;

/**

* java多线程模拟生产者消费者问题

*

* ProducerConsumer是主类，Producer生产者，Consumer消费者，Product产品，Storage仓库

*

* @author 林计钦

* @version 1.0 2013-7-24 下午04:49:02

*/

public class ProducerConsumer {

public static void main(String[] args) {

ProducerConsumer pc = new ProducerConsumer();

Storage s = pc.new Storage();

ExecutorService service = Executors.newCachedThreadPool();

Producer p = pc.new Producer("张三", s);

Producer p2 = pc.new Producer("李四", s);

Consumer c = pc.new Consumer("王五", s);

Consumer c2 = pc.new Consumer("老刘", s);

Consumer c3 = pc.new Consumer("老林", s);

service.submit(p);

//service.submit(p2);

service.submit(c);

service.submit(c2);

service.submit(c3);

}

/**

* 消费者

*

* @author 林计钦

* @version 1.0 2013-7-24 下午04:53:30

*/

class Consumer implements Runnable {

private String name;

private Storage s = null;

public Consumer(String name, Storage s) {

this.name = name;

this.s = s;

}

public void run() {

try {

while (true) {

System.out.println(name "准备消费产品.");

Product product = s.pop();

System.out.println(name "已消费(" product.toString() ").");

System.out.println("===============");

Thread.sleep(500);

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

/**

* 生产者

*

* @author 林计钦

* @version 1.0 2013-7-24 下午04:53:44

*/

class Producer implements Runnable {

private String name;

private Storage s = null;

public Producer(String name, Storage s) {

this.name = name;

this.s = s;

}

public void run() {

try {

while (true) {

Product product = new Product((int) (Math.random() * 10000)); // 产生0~9999随机整数

System.out.println(name "准备生产(" product.toString() ").");

s.push(product);

System.out.println(name "已生产(" product.toString() ").");

System.out.println("===============");

Thread.sleep(500);

}

} catch (InterruptedException e1) {

e1.printStackTrace();

}

}

}

/**

* 仓库，用来存放产品

*

* @author 林计钦

* @version 1.0 2013-7-24 下午04:54:16

*/

public class Storage {

BlockingQueue queues = new LinkedBlockingQueue(10);

/**

* 生产

*

* @param p

*            产品

* @throws InterruptedException

*/

public void push(Product p) throws InterruptedException {

queues.put(p);

}

/**

* 消费

*

* @return 产品

* @throws InterruptedException

*/

public Product pop() throws InterruptedException {

return queues.take();

}

}

/**

* 产品

*

* @author 林计钦

* @version 1.0 2013-7-24 下午04:54:04

*/

public class Product {

private int id;

public Product(int id) {

this.id = id;

}

public String toString() {// 重写toString方法

return "产品：" this.id;

}

}

}

结果

张三准备生产(产品：3359).

张三已生产(产品：3359).

===============

老刘准备消费产品.

王五已消费(产品：3359).

===============

王五准备消费产品.

张三准备生产(产品：1863).

张三已生产(产品：1863).

===============

老林已消费(产品：1863).

===============

老林准备消费产品.

张三准备生产(产品：5424).

张三已生产(产品：5424).

老刘已消费(产品：5424).

===============

===============

张三准备生产(产品：6290).

张三已生产(产品：6290).

===============

老刘准备消费产品.

王五已消费(产品：6290).

===============

张三准备生产(产品：990).

张三已生产(产品：990).

===============

老林已消费(产品：990).

===============

王五准备消费产品.

张三准备生产(产品：1971).

老林准备消费产品.

老刘已消费(产品：1971).

===============

张三已生产(产品：1971).

===============

张三准备生产(产品：5622).

老刘准备消费产品.

张三已生产(产品：5622).

===============

王五已消费(产品：5622).

===============

王五准备消费产品.

张三准备生产(产品：6570).

张三已生产(产品：6570).

===============

老林已消费(产品：6570).

===============

老林准备消费产品.

张三准备生产(产品：17).

老刘已消费(产品：17).

===============

张三已生产(产品：17).

===============

老刘准备消费产品.

张三准备生产(产品：7962).

张三已生产(产品：7962).

===============

王五已消费(产品：7962).

===============

王五准备消费产品.

张三准备生产(产品：3200).

张三已生产(产品：3200).

===============

老林已消费(产品：3200).

===============

老林准备消费产品.

张三准备生产(产品：7234).

张三已生产(产品：7234).

===============

老刘已消费(产品：7234).

===============

老刘准备消费产品.

张三准备生产(产品：6486).

张三已生产(产品：6486).

===============

王五已消费(产品：6486).

===============

张三准备生产(产品：5436).

王五准备消费产品.

王五已消费(产品：5436).

===============