消费者和生产者问题

 

线程四个状态：start、running、 waiting、 stop。即新生状态，运行状态，阻塞状态，死亡状态。

对于游戏厅里的情况有：正在玩游戏的人，在排队的人，在沙发上休息的人，在宿舍休息的人四种情况。

Object.wait()  ：到沙发上去休息。其他人上游戏机玩，适当时候被叫醒。但得等别人玩够了交出凳子时才能再继续玩。（对不起，虽然我叫醒了你，但你的让我玩完你才能玩）

Object.notify()：把在沙发上的人叫醒，来玩游戏。

Object.notifyAll()：把沙发上所有的人叫醒，来玩游戏，但要排队哦。

Thread.sleep(); 回宿舍睡觉，游戏机空闲，没人玩。睡醒后继续玩洛。当前线程处于阻塞状态，并且不会释放锁

Thread.yield(); 玩游戏时间到(比如最多一小时)从游戏机上下来，让出cup 给其它线程。重新在队列中排队。当前线程仍然是可运行状态，也不释放锁

Thread.run()：正在玩游戏。

金典生产者和消费者的例子：

 /**

ProductStack 是一个生产者跟消费者共享的同步机制，这个机制决定了什么情况生产者要wait()，什么情况消费者要wait()

 

  可以把ProductStack看作一个产品仓库。当产品仓库满的时候，生产者线程需要wait()，从而放弃对产品仓库的控制。

 

  这个时候消费者线程就可以进来了而取得仓库的控制权。一旦消费者消费了产品，那么仓库就不满了。

 

  这个时候消费者线程就要notifyAll()生产者线程，让等待的生产者线程唤醒。

 

  但是生产者被唤醒后不能马上进行生产，因为它在wait()的时候已经丧失了对仓库的控制权，所以就需要等待消费者线程结束操作，

  才能重新取得仓库的控制权，再进行生产。

  所以特别注意的是，notifyAll()并不是让当前线程马上让出控制权，而只是让其他wait()当中的线程唤醒而已，所以对不起，尽管我唤醒你，可你必须还是要等我用完仓库才能进来。这点必须清楚。

  相反，仓库如果空的时候，消费者线程就会wait()，然后等待生产者线程来生产产品，生产者进程乘虚而入后，让生产者线程生产产品并且唤醒消费者线程。这个情况跟上面就类似了。 */

1 商品类

class Product{
 int id;
 private String producedBy="N/A";
 private String consumedBy="N/B";
 //构造函数，指明产品id及生产者姓名
 public Product(int id,String produceBy){
  this.id=id;
  this.producedBy=producedBy;
 }
 //消费者名称
 public void consume(String consumedBy){
  this.consumedBy=consumedBy;
 }
 
 public String toString(){
  return "Product:"+id+",Product by"+producedBy+",consumed by"+consumedBy;
 }
 
 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;
  }
}

2 生产线程代码

class Producer implements Runnable{
 String name;
 ProductStack ps=null;
 public Producer(ProductStack ps,String name){
  this.ps=ps;
  this.name=name;
 }
 public void run(){
  for(int i=0;i<20;i++){
   Product product=new Product(i,name);
   ps.push(product);
   try{
    Thread.sleep((int)(Math.random()*200));
   }catch(Exception ex){
    ex.printStackTrace();
   }
  }
 }
}

3 消费线程代码

class Consumer implements Runnable{
 String name;
 ProductStack ps=null;
 public Consumer(ProductStack ps,String name){
  this.ps=ps;
  this.name=name;
 }
 public void run(){
  for(int i=0;i<20;i++){
   Product p=ps.pop(name);
   try{
    Thread.sleep((int)(Math.random()*1000));
   }catch(Exception ex){
    ex.printStackTrace();
   }
  }
 }
}

4  产品仓库

class ProductStack{
 int index=0;
 Product proArray[]=new Product[6];
 //生产者放置产品
 public synchronized void  push(Product product){
  while(index==proArray.length){
   try{
    System.out.println(product.getProducedBy()+"is wait");
    wait();//仓库已满生产者等待并退出cup
   }catch(Exception ex){
    ex.printStackTrace();
   }
  }
  System.out.println(product.getProducedBy()+"send a notifyAll()");
  notifyAll();//既然有产品就唤醒他们来。准备消费，但还没有消费
  proArray[index]=product;
  index++;
  System.out.println(product.getProducedBy()+"生产了："+product);
 }
 //消费者取出产品
 public synchronized Product pop(String consumerName){
  //如果仓库是空的
  while(index==0){
   try{
    System.out.println(consumerName+"is waiting");
    wait();
   }catch(Exception ex){
    ex.printStackTrace();
   }
  }
  //因为我们不确定有没有线程在wait()，所以我们既然消费了产品，就唤醒有可能等待的生产者，让他们醒来，准备生产
  System.out.println(consumerName+"send a notifyAll()");
  notifyAll();
  // 注意，notifyAll()以后，并没有退出，而是继续执行直到完成。
  index--;
  Product product= proArray[index];
  product.consume(consumerName);
  System.out.println(product.getConsumedBy()+"消费了:"+product);
  return product;
 }
}

5 主调类

/**
主调函数
*/
public class ProduceConsumer{
 public static void main(String []args){
  ProductStack ps=new ProductStack();
  Producer p=new Producer(ps,"生产者1");
  Consumer c=new Consumer(ps,"消费者1");
  new Thread(p).start();
  new Thread(c).start();
 }
}
运行结果：

N/Asend a notifyAll()
N/A生产了：Product:0,Product byN/A,consumed byN/B
消费者1send a notifyAll()
消费者1消费了:Product:0,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:1,Product byN/A,consumed byN/B
N/Asend a notifyAll()
N/A生产了：Product:2,Product byN/A,consumed byN/B
消费者1send a notifyAll()
消费者1消费了:Product:2,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:3,Product byN/A,consumed byN/B
N/Asend a notifyAll()
N/A生产了：Product:4,Product byN/A,consumed byN/B
N/Asend a notifyAll()
N/A生产了：Product:5,Product byN/A,consumed byN/B
N/Asend a notifyAll()
N/A生产了：Product:6,Product byN/A,consumed byN/B
N/Asend a notifyAll()
N/A生产了：Product:7,Product byN/A,consumed byN/B
消费者1send a notifyAll()
消费者1消费了:Product:7,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:8,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:8,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:9,Product byN/A,consumed byN/B
消费者1send a notifyAll()
消费者1消费了:Product:9,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:10,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:10,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:11,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:11,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:12,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:12,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:13,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:13,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:14,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:14,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:15,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:15,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:16,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:16,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:17,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:17,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:18,Product byN/A,consumed byN/B
N/Ais wait
消费者1send a notifyAll()
消费者1消费了:Product:18,Product byN/A,consumed by消费者1
N/Asend a notifyAll()
N/A生产了：Product:19,Product byN/A,consumed byN/B
消费者1send a notifyAll()
消费者1消费了:Product:19,Product byN/A,consumed by消费者1
消费者1send a notifyAll()
消费者1消费了:Product:6,Product byN/A,consumed by消费者1
消费者1send a notifyAll()
消费者1消费了:Product:5,Product byN/A,consumed by消费者1
消费者1send a notifyAll()
消费者1消费了:Product:4,Product byN/A,consumed by消费者1
消费者1send a notifyAll()
消费者1消费了:Product:3,Product byN/A,consumed by消费者1
消费者1send a notifyAll()
消费者1消费了:Product:1,Product byN/A,consumed by消费者1