java实现生产消费者问题

问题分析：在任意时刻，生产者往盘子里放置一个面包（也可以有多个），对应消费者（可以有多个）从盘子里取面包；

当盘子满了时，生产者执行wait操作，等待消费者消费并唤醒自己；同理当盘子空了时，消费者执行wait操作，并等待生产者唤醒自己

用面向对象的思维分析问题：问题中共有四个类，分别是面包，盘子，生产者，消费者；

这四个类应实现的方法为：面包的构造方法和重写的toString，盘子：拿出（pop）和f放入（push），这两个方法需要加锁，实现互斥；

生产者、消费者应实现run（）方法。。。。。

public class procon{

public  static void main(String[ ] args){

breadBag ba=new breadBag();

producer pro=new producer(ba);

consumer con =new consumer(ba);

Thread t1=new Thread(pro);//也可以起多个生产者线程

Thread t2=new Thread(con);//也可以起多个消费者线程

t1.start();

t2.start();

}

}

class Bread{

private int id;

public Bread(int id){

this.id=id;}

public String toString(){

return "bread:"+id;

}

}

class breadBag{

Bread[ ] breadArr=new Bread[6];

private int index=0;

public synchronized push(Bread ba){

while(index==breadArr.length){

try{

this.wait();}

catch(InterruptedException e){

e.printStackTrace();}

}

this.notifyAll();

breadArr[index]=bread;

index++;

}

public synchronized  Bread pop(){

while(index==0){

try{

this.wait();

}

catch(InterruptException e){

e.printStackTrance();

}

}

index--;

return breadArr[index];

}

}

class producer implements Runnable{

breadBag ba=null;

public producer(breadBag ba){

this.ba=ba;}

public void run(){

for(int i=0;i<20;i++){

Bread bread=new Bread[i];

ba.push(bread);

System.out.println("生产了"+bread);

//可以sleep（）一下，控制进程执行速度

}

}

}

class consumer implements Runnable{

breadBag ba=null;

consumer(breadBag ba){

this.ba=ba;

}

public void run(){

for(int i=0;i<20;i++){

Bread ba=ba.pop();

System.out.println("消费了"+ba);

//可以sleep（）一下，控制进程执行速度

}

}

}

问题分析：在任意时刻，生产者往盘子里放置一个面包（也可以有多个），对应消费者（可以有多个）从盘子里取面包；

当盘子满了时，生产者执行wait操作，等待消费者消费并唤醒自己；同理当盘子空了时，消费者执行wait操作，并等待生产者唤醒自己

用面向对象的思维分析问题：问题中共有四个类，分别是面包，盘子，生产者，消费者；

这四个类应实现的方法为：面包的构造方法和重写的toString，盘子：拿出（pop）和f放入（push），这两个方法需要加锁，实现互斥；

生产者、消费者应实现run（）方法。。。。。

public class procon{

public  static void main(String[ ] args){

breadBag ba=new breadBag();

producer pro=new producer(ba);

consumer con =new consumer(ba);

Thread t1=new Thread(pro);//也可以起多个生产者线程

Thread t2=new Thread(con);//也可以起多个消费者线程

t1.start();

t2.start();

}

}

class Bread{

private int id;

public Bread(int id){

this.id=id;}

public String toString(){

return "bread:"+id;

}

}

class breadBag{

Bread[ ] breadArr=new Bread[6];

private int index=0;

public synchronized push(Bread ba){

while(index==breadArr.length){

try{

this.wait();}

catch(InterruptedException e){

e.printStackTrace();}

}

this.notifyAll();

breadArr[index]=bread;

index++;

}

public synchronized  Bread pop(){

while(index==0){

try{

this.wait();

}

catch(InterruptException e){

e.printStackTrance();

}

}

index--;

return breadArr[index];

}

}

class producer implements Runnable{

breadBag ba=null;

public producer(breadBag ba){

this.ba=ba;}

public void run(){

for(int i=0;i<20;i++){

Bread bread=new Bread[i];

ba.push(bread);

System.out.println("生产了"+bread);

//可以sleep（）一下，控制进程执行速度

}

}

}

class consumer implements Runnable{

breadBag ba=null;

consumer(breadBag ba){

this.ba=ba;

}

public void run(){

for(int i=0;i<20;i++){

Bread ba=ba.pop();

System.out.println("消费了"+ba);

//可以sleep（）一下，控制进程执行速度

}

}

}