Java 多线程同步生产者消费者问题-monitor

　对这个问题更深一点理解是，每一个线程都在竞争这个类的实例的monitor对象。

　　java会为每个object对象分配一个monitor，当某个对象的同步方法（synchronized methods ）被多个线程调用时，该对象的monitor将负责处理这些访问的并发独占要求。

　　任何时刻，对一个指定object对象的某同步方法只能由一个线程来调用。java对象的monitor是跟随object实例来使用的，而不是跟随程序代码。两个线程可以同时执行相同的同步方法，比如：一个类的同步方法是xMethod()，有a,b两个对象实例，一个线程执行a.xMethod()，另一个线程执行b.xMethod(). 互不冲突。下面是单生产者单消费者的实例

 /*
  * 生产者消费者
  * 分类:
  * 单生产者单消费者
  * 多生产者的消费者
  *
  *
  * 单生产者单消费者:
  * 两个线程:生产线程,消费线程
  * 两个任务:生产任务,消费任务
  * 一份数据
  */
 public class Demo4 {
     public static void main(String[] args) {
         //1.准备数据
         Product product = new Product();
         //2.创建生产消费任务
         Producer producer = new Producer(product);
         Consumer consumer = new Consumer(product);
         //3.创建生产消费线程
         Thread thread1 = new Thread(producer);
         Thread thread2 = new Thread(consumer);
         //4.开启线程
         thread1.start();
         thread2.start();
     }
 }

 //数据类
 class Product{
     String name;
     double price;
     int count;

     //标识
     boolean flag;

     //准备生产
     public synchronized void setProduce(String name,double price) {
         if (flag == true) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }

         this.name = name;
         this.price = price;

         System.out.println(Thread.currentThread().getName()+"  生产了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

         count++;

         flag = !flag;

         //唤醒消费线程
         notify();
     }
     //准备消费
     public synchronized void consume() {
         if (flag == false) {
             try {
                 wait();
             } catch (InterruptedException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         }

         System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

         flag = !flag;

         //唤醒生产线程
         notify();
     }
 }
 //生产任务
 class Producer implements Runnable{
     Product product;

     public Producer(Product product) {
         super();
         this.product = product;
     }

     public void run() {
         while (true) {
             product.setProduce("bingbing", 10);
         }
     }
 }
 //消费任务

 class Consumer implements Runnable{
     Product product;

     public Consumer(Product product) {
         super();
         this.product = product;
     }

     public void run() {
         while (true) {
             product.consume();
         }
     }
 }

生产者消

　多生产者多消费者:
 * 两个生产线程,两个消费线程
 * 两个任务:生产任务,消费任务
 * 一份数据
 *
 * 生产任务与消费任务共用一个数据--产品类
 *
 * 要求:最终也要实现一次生产一次消费
 *
 *错误描述:当有两个生产线程,两个消费线程同时存在的时候,有可能出现生产一次,消费多次或者生产多次消费一次的情况.
 *原因:当线程被重新唤醒之后,没有判断标记,直接执行了下面的代码
 *
 *解决办法:将标记处的if改成while
 *
 *问题描述:继续运行程序,会出现死锁的情况(4个线程同时处于等待状态)
 *原因:唤醒的是本方的线程,最后导致所有的线程都处于等待状态.
 *
 *解决办法:将notify改成notifyAll.保证将对方的线程唤醒
 *
 *死锁:出现的情况有两种
 *1.所有的线程处于等待状态
 *2.锁之间进行嵌套调用
 *
 */

public class Demo5 {
    public static void main(String[] args) {
        //1.准备数据
        Product1 product = new Product1();
        //2.创建生产消费任务
        Producer1 producer = new Producer1(product);
        Consumer1 consumer = new Consumer1(product);
        //3.创建生产消费线程
        Thread thread0 = new Thread(producer);
        Thread thread1 = new Thread(producer);
        Thread thread2 = new Thread(consumer);
        Thread thread3 = new Thread(consumer);
        //4.开启线程
        thread0.start();
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

//数据类
class Product1{
    String name;
    double price;
    int count;

    //标识
    boolean flag;

    //准备生产
    public synchronized void setProduce(String name,double price) {
        while (flag == true) {
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        this.name = name;
        this.price = price;

        System.out.println(Thread.currentThread().getName()+"  生产了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

        count++;

        flag = !flag;

        //唤醒消费线程
        //notify();
        notifyAll();
    }
    //准备消费
    public synchronized void consume() {
        while (flag == false) {
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        System.out.println(Thread.currentThread().getName()+"  消费了:"+name+"  产品的数量:"+count+"  产品的价格:"+price);

        flag = !flag;

        //唤醒生产线程
        //notify();
        notifyAll();
    }
}
//生产任务
class Producer1 implements Runnable{
    Product1 product;

    public Producer1(Product1 product) {
        super();
        this.product = product;
    }

    public void run() {
        while (true) {
            product.setProduce("bingbing", 10);
        }
    }
}
//消费任务

class Consumer1 implements Runnable{
    Product1 product;

    public Consumer1(Product1 product) {
        super();
        this.product = product;
    }

    public void run() {
        while (true) {
            product.consume();
        }
    }
}