本文章为小编原创，请尊重文章的原创性，转载请注意写明转载来源：http://blog.csdn.net/u012116457
已知技术参数：
生产者消费者问题，描述一组生产者向一组消费者提*品/消息。它们共享一个有界缓冲区，生产者向其中放产品/消息，消费者从中取产品/消息。只要缓冲区未满，生产者可放产品/消息，只要缓冲区有数据，消费者可取消息。即应满足下列二个同步条件：
1.只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才能从中提取消息，否则消费者必须等待。
2.只有缓冲池中至少有一个缓冲区是空时，生产者才能把消息放入缓冲区，否则生产者必须等待。
设计要求：
要求设定一个缓冲池中有n个缓冲区，每个缓冲区存放一个消息，创建多个生产者，消费者，并在每个生产者消费者创建时、发出放/取产品申请时、正在放/取产品时和放/取产品结束时分别给出提示信息，并显示取/方产品前后的缓冲区状态，以检查所有处理都遵守相应的操作限制。
上代码：
最核心的代码：
package kcsj;
/**
* 模拟实现生产者--消费者问题
*
* @date 2014/06/24
*
*/
public class ProductiveConsumption {
private int front=0; //队头
private int next=0; //队尾
private int bufferLength; //缓冲区大小
private String buffer[]; //缓冲区
private int emptyNum; //空缓冲区数目
public ProductiveConsumption(int bufferLength){
this.bufferLength=bufferLength;
buffer=new String[bufferLength];
emptyNum=bufferLength;
}
//生产
public synchronized void produce(String data){
System.out.println("生产前,空缓冲区数目-----------"+emptyNum);
System.out.println("***生产者正在生产"+data);
while(full()){
System.out.println("*****缓冲池已满，生产等待");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
buffer[next]=data;
next=(next+1)%bufferLength;
System.out.println("****生产者成功生产："+data);
emptyNum--;
System.out.println("生产后,空缓冲区数目-----------"+emptyNum);
}
//消费
public synchronized void consum(){
System.out.println("消费前,空缓冲区数目-----------"+emptyNum);
while(empty()){
System.out.println("*****缓冲池为空，消费等待");
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("***消费者正在消费"+buffer[front]);
this.notify();
System.out.println("****消费者成功消费："+buffer[front]);
front=(front+1)%bufferLength;
emptyNum++;
System.out.println("消费后,空缓冲区数目-----------"+emptyNum);
}
//缓冲池是否已满
public boolean full(){
if(emptyNum==0){
return true;
}
return false;
}
//缓冲池是否为空
public boolean empty(){
if(bufferLength==emptyNum){
return true;
}
return false;
}
}
其他辅助代码：
package kcsj;
/**
*创建生产者
*/
public class CreateProducer implements Runnable{
ProductiveConsumption pc;
int producerNum;
public CreateProducer(ProductiveConsumption pc,int producerNum){
this.pc=pc;
this.producerNum=producerNum;
}
public void run(){
for(int i=0;i<producerNum;i++){
Producer producer=new Producer(pc);
try {
Thread.sleep((int)(Math.random()*100));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package kcsj;
/**
*创建消费者
*/
public class CreateConsumer implements Runnable{
ProductiveConsumption pc;
int consumerNum;
public CreateConsumer(ProductiveConsumption pc,int consumerNum){
this.pc=pc;
this.consumerNum=consumerNum;
}
public void run(){
for(int i=0;i<consumerNum;i++){
Consumer consumer=new Consumer(pc);
try {
Thread.sleep((int)(Math.random()*100));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
package kcsj;
public class Producer{
ProductiveConsumption pc;
public Producer(ProductiveConsumption pc){
this.pc=pc;
System.out.println("*成功创建一个生产者");
apply();
}
public void apply(){
char c=(char)(Math.random()*26+'A');
String data=String.valueOf(c);
System.out.println("**生产者发出请求");
pc.produce(data);
}
}
package kcsj;
public class Consumer{
ProductiveConsumption pc;
public Consumer(ProductiveConsumption pc){
this.pc=pc;
System.out.println("*成功创建一个消费者");
apply();
}
public void apply() {
System.out.println("**消费者发出请求");
pc.consum();
}
}
package kcsj;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("输入缓冲区大小");
int buffLength=sc.nextInt();
System.out.println("输入生产者和消费者个数");
int prodecerNum=sc.nextInt();
int consumerNum=sc.nextInt();
ProductiveConsumption pc=new ProductiveConsumption(buffLength);
Runnable cp=new CreateProducer(pc,prodecerNum);
Runnable cc=new CreateConsumer(pc,consumerNum);
Thread t1=new Thread(cp);
Thread t2=new Thread(cc);
t1.start();
t2.start();
}
}