生产者和消费者

package thread;

/**
* 产品仓库类
* @author wxg1022
*
*/
public class ProductList {

int index=0;
Product[] productlist=new Product[6];

public synchronized void push(Product product){
while(index==productlist.length){
try{
System.out.println("仓库已经满了，所以"+product.getProducedBy()+" 等等再生产");
//等待                             wait();
                                     //在这里等获取机会继续执行，并判断while(index==0)是否成立来执行

}catch(Exception e){
e.printStackTrace();
}
}
System.out.println("我来生产1个！");
//注意：notifyAll()以后，并没有退出，而是继续执行直到完成
productlist[index]=product;
index++;
//因为我们不确定有没有线程在wait()，所以我们既然生产了产品，就唤醒有可能等待的消费者，让他们醒来，准备消费
notifyAll();
System.out.println(" "+product.getProducedBy()+" sent a notifyAll()");
}

//pop用来让消费者取出产品
public synchronized Product pop(String consumerName){
//仓库空了
System.out.println(consumerName+"进来消费!");
while(index==0){
try{
System.out.println("没有可以消费的，所以"+consumerName+"等等再消费");
//等待                            wait();
                                     //在这里等获取机会继续执行，并判断while(index==0)是否成立来执行
}catch(Exception e){
e.printStackTrace();
}
}
System.out.print("我来消费1个！");
index--;
Product product=productlist[index];
product.consume(consumerName);

System.out.print("还剩"+index+"个产品，"+product.getConsumedBy()+ " 消费了："+product);
//因为我们不能确定有没有线程在wait(),所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
notifyAll();
System.out.println(" "+consumerName+" send a notifyAll()");
return product;

}
}


package thread;

/**
* 产品类
* @author wxg1022
*
*/

public class Product {

int id;
private String producedBy="N/A";//谁生产的
private String consumedBy="N/A";//谁消费的

//构造函数指明生产者姓名
public Product(String producedBy) {
this.producedBy=producedBy;
// TODO Auto-generated constructor stub
}
//消费，需要指定消费者的名字
public void consume(String consumedBy){
this.consumedBy=consumedBy;
}

public String toString(){
return "产品[生产者="+producedBy+",消费者="+consumedBy+"]"; }

//以下是get/set方法
public String getProducedBy() {
return producedBy;
}
public void setProducedBy(String producedBy) {
this.producedBy = producedBy;
}
public String getConsumedBy() {
return consumedBy;
}
public void setConsumedBy(String consumedBy) {
this.consumedBy = consumedBy;
}



}


package thread;

/**
* 生产者类
* @author wxg1022
*
*/
public class Producer implements Runnable {

String name;
ProductList ps=null;

Producer(ProductList ps,String name){
this.ps=ps;
this.name=name;
}

@Override
public void run() {
// TODO Auto-generated method stub
while(true){
Product product=new Product(name);
ps.push(product);

try{
Thread.sleep((int)(Math.random()*2000));
}catch(Exception ee){
ee.printStackTrace();
}
}
}

}

package thread;

public class Consumer implements Runnable {

String name;
ProductList ps=null;

Consumer(ProductList ps,String name){
this.name=name;
this.ps=ps;
}
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
ps.pop(name);
try{
Thread.sleep((int)(Math.random()*2000));
}catch(Exception ee){
ee.printStackTrace();
}
}
}

}


package thread;

public class ProducerCusumer {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ProductList ps=new ProductList();
Producer px=new Producer(ps,"生产者X");
Producer py=new Producer(ps,"生产者Y");
Consumer ca=new Consumer(ps,"消费者A");
Consumer cb=new Consumer(ps,"消费者B");
Consumer cc=new Consumer(ps,"消费者C");
new Thread(px).start();
new Thread(py).start();
new Thread(ca).start();
new Thread(cb).start();
new Thread(cc).start();
}

}


运行结果如下：

我来生产1个！
生产者X sent a notifyAll()
我来生产1个！
生产者Y sent a notifyAll()
消费者A进来消费!
我来消费1个！还剩1个产品，消费者A 消费了：产品[生产者=生产者Y,消费者=消费者A] 消费者A send a notifyAll()
消费者B进来消费!
我来消费1个！还剩0个产品，消费者B 消费了：产品[生产者=生产者X,消费者=消费者B] 消费者B send a notifyAll()
消费者C进来消费!
没有可以消费的，所以消费者C等等再消费
我来生产1个！
生产者Y sent a notifyAll()
我来消费1个！还剩0个产品，消费者C 消费了：产品[生产者=生产者Y,消费者=消费者C] 消费者C send a notifyAll()
消费者A进来消费!
没有可以消费的，所以消费者A等等再消费
消费者B进来消费!
没有可以消费的，所以消费者B等等再消费
我来生产1个！
生产者Y sent a notifyAll()
我来消费1个！还剩0个产品，消费者B 消费了：产品[生产者=生产者Y,消费者=消费者B] 消费者B send a notifyAll()
没有可以消费的，所以消费者A等等再消费
我来生产1个！
生产者X sent a notifyAll()
我来消费1个！还剩0个产品，消费者A 消费了：产品[生产者=生产者X,消费者=消费者A] 消费者A send a notifyAll()
消费者A进来消费!
没有可以消费的，所以消费者A等等再消费
消费者B进来消费!
没有可以消费的，所以消费者B等等再消费
消费者C进来消费!
没有可以消费的，所以消费者C等等再消费
我来生产1个！
生产者X sent a notifyAll()
我来消费1个！还剩0个产品，消费者C 消费了：产品[生产者=生产者X,消费者=消费者C] 消费者C send a notifyAll()
没有可以消费的，所以消费者B等等再消费
我来生产1个！
生产者Y sent a notifyAll()
我来消费1个！还剩0个产品，消费者A 消费了：产品[生产者=生产者Y,消费者=消费者A] 消费者A send a notifyAll()
没有可以消费的，所以消费者B等等再消费
消费者C进来消费!
没有可以消费的，所以消费者C等等再消费
消费者A进来消费!
没有可以消费的，所以消费者A等等再消费
我来生产1个！
生产者Y sent a notifyAll()
我来消费1个！还剩0个产品，消费者A 消费了：产品[生产者=生产者Y,消费者=消费者A] 消费者A send a notifyAll()
没有可以消费的，所以消费者C等等再消费
没有可以消费的，所以消费者B等等再消费
我来生产1个！
生产者X sent a notifyAll()
我来消费1个！还剩0个产品，消费者B 消费了：产品[生产者=生产者X,消费者=消费者B] 消费者B send a notifyAll()
没有可以消费的，所以消费者C等等再消费
我来生产1个！
生产者Y sent a notifyAll()
我来消费1个！还剩0个产品，消费者C 消费了：产品[生产者=生产者Y,消费者=消费者C] 消费者C send a notifyAll()
消费者B进来消费!
没有可以消费的，所以消费者B等等再消费
我来生产1个！
生产者Y sent a notifyAll()
......................................

从以上运行的结果可以得出如下几点结论
1执行notifyAll()后，对于等待中的线程不能确地是谁能获取运行的机会。
2当执行wait()后，该线程后续的代码将会暂停执行，等获取执行机会后会接着执行，而不是重新执行。
3使用while而不是用if的原因