生产者和消费者

/*生产者消费者问题：
  多个生产者，多个消费者的时候，注意要用while判断标记，是否生产还是消费
  要用notifyAll()
*/
class Resource
{
    private String name;//商品名称
    private int count = 1;//商品出厂编号
    private boolean flag;//判断标记
    public synchronized void set(String name){
      while(flag)
          try{this.wait();}catch(InterruptedException e){}
      this.name = name+"--"+count++;
      System.out.println(Thread.currentThread().getName()+"....生产者...."+this.name);
      flag = true;
      this.notifyAll();
    }
    public synchronized void out(){
      while(!flag)
          try{this.wait();}catch(InterruptedException e){}
      System.out.println(Thread.currentThread().getName()+"消费者"+this.name);
      flag = false;
      this.notifyAll();
    }
}
class Producer implements Runnable
{
    private Resource r;
    Producer(Resource r){
      this.r = r;
    }
    public void run(){
      while(true)
          r.set("商品");
    }
}
class Consumer implements Runnable
{
    private Resource r;
    Consumer(Resource r){
      this.r = r;
    }
    public void run(){
      while(true)
          r.out();
    }
}
class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);//两个生产者
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);//两个消费者
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
  }
}

升级程序：notifyAll()会唤醒本方和对方的等待线程，要求只唤醒对方线程。

/*生产者消费者问题：
  多个生产者，多个消费者的时候，注意要用while判断标记
  将r.wait();r.notify();换成lock.lock(); lock.unlock();condition.await();condition.signal();
  jdk1.5以后lock替代了synchronized方法和语句的使用，Condition替代了object监视器方法（wait(),notify(),notifyAll()）的使用。
  JDK1.5中提供了多线程的升级解决方案。
  将同步synchronized替换成现实Lock锁。
  将Object中的wait，notify，notifyAll，替换成Condition对象
  该对象可以Lock锁 进行获取
  该示例中实现了本方只唤醒对方
*/
import java.util.concurrent.locks.*;
class Resource
{
    private String name;//商品名称
    private int count = 1;//商品出厂编号
    private boolean flag;//判断标记
    private Lock lock = new ReentrantLock();
    //一个锁上可以有多个相关的condition
    private Condition condition_pro = lock.newCondition();
    private Condition condition_con = lock.newCondition();
    public void set(String name) throws InterruptedException{
        lock.lock();
        try{
        while(flag)
          condition_pro.await();
      this.name = name+"--"+count++;
      System.out.println(Thread.currentThread().getName()+"....生产者...."+this.name);
      flag = true;
      condition_con.signal();
        }finally{
          lock.unlock();
        }
    }
    public void out() throws InterruptedException{
        lock.lock();
        try{
         while(!flag)
         condition_con.await();
      System.out.println(Thread.currentThread().getName()+"消费者"+this.name);
       flag = false;
      condition_pro.signal();
        }finally{
          lock.unlock();
        }
    }
}
class Producer implements Runnable
{
    private Resource r;
    Producer(Resource r){
      this.r = r;
    }
    public void run(){
      while(true)
          try{r.set("商品");}catch(InterruptedException e){}
    }
}
class Consumer implements Runnable
{
    private Resource r;
    Consumer(Resource r){
      this.r = r;
    }
    public void run(){
      while(true)
           try{r.out();}catch(InterruptedException e){}
    }
}
class ProducerConsumerDemo
{
    public static void main(String[] args)
    {
        Resource r = new Resource();
        Producer pro = new Producer(r);
        Consumer con = new Consumer(r);
        Thread t1 = new Thread(pro);//两个生产者
        Thread t2 = new Thread(pro);
        Thread t3 = new Thread(con);//两个消费者
        Thread t4 = new Thread(con);
        t1.start();
        t2.start();
        t3.start();
        t4.start();
  }
}