Java等待唤醒机制深入理解

昨天写了关于多线程引发的并发问题及解决方案—锁，然后咱们今天继续…

一、并发分析

Java中有个概念，叫生产者与消费者。

假设生产者不停轮流生产苹果和香蕉，其中苹果的价格是10元/kg，香蕉的价格是5元/kg，消费者则是对生产的商品进行购买，显然，这里的生产者生产的商品和消费者消费的商品是同一个商品。
定义产品类，生产者类，消费者类，因为需要共享商品，采取的策略是主方法中创建产品类对象，并将其作为参数传入生产者和消费者的构造函数中。

//产品类
class Product{
    String name;  //名字
    double price;  //价格
}

//生产者
class Producer extends Thread{
    
    Product  p ;    //产品
    
    public Producer(Product p) {
        this.p  = p ;
    } 
    
    @Override
    public void run() {
        int i = 0 ;
        while(true){
            if(i%2==0){
                 p.name = "苹果";
                 p.price = 10;
             }else{
                 p.name="香蕉";
                 p.price = 5;
             }
            System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
            i++;           
        } 
      }
    }
}

//消费者
class Customer extends Thread{
    
    Product p;
    
    public  Customer(Product p) {
        this.p = p;
    }
        
    @Override
    public void run() {
        while(true){
                    System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
        } 
    }
}

//测试类
public class Demo5 {
    
    public static void main(String[] args) {
        Product p = new Product();  //产品
        //创建生产对象
        Producer producer = new Producer(p);
        //创建消费者
        Customer customer = new Customer(p);
        //调用start方法开启线程
        producer.start();
        customer.start();
    } 
}

观察代码，我们会发现两个问题

1.没有生产出商品，消费者也来消费了

2.商品的价格发生了错乱
了解线程以及其安全问题的话，这两个问题并不难分析。

二、需求分析

显然，我们需要生产者每生产一个就进入等待，唤醒消费者消费，消费者消费一个，消费完后进入等待，唤醒生产者继续生产，这样的话，必须要等待生产者彻底生产完毕，消费者才能进行商品的消费，且价格不会发生错乱。java提供了wait()和notify()|notifyAll()（唤醒所有锁对象为标识符的线程池中所有的线程）方法解决这个问题，即等待唤醒机制。

//产品类
class Product{
    String name;  //名字
    double price;  //价格
    boolean flag = false; //产品是否生产完毕的标识，默认情况是没有生产完成。
}

//生产者
class Producer extends Thread{
    
    Product  p ;    //产品
    
    public Producer(Product p) {
        this.p  = p ;
    }
 
    @Override
    public void run() {
        int i = 0 ;
        while(true){
         synchronized (p) {
            if(p.flag==false){
                 if(i%2==0){
                     p.name = "苹果";
                     p.price = 10;
                 }else{
                     p.name="香蕉";
                     p.price = 5;
                 }
                 System.out.println("生产者生产出了："+ p.name+" 价格是："+ p.price);
                 p.flag = true;
                 i++;
                 p.notifyAll(); //唤醒消费者去消费
            }else{
                //已经生产 完毕，等待消费者先去消费
                try {
                    p.wait();   //生产者等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }  
         }
        } 
    }
}

//消费者
class Customer extends Thread{
    
    Product p;
    
    public  Customer(Product p) {
        this.p = p;
    }
        
    @Override
    public void run() {
        while(true){
            synchronized (p) {
                if(p.flag==true){  //产品已经生产完毕
                    System.out.println("消费者消费了"+p.name+" 价格："+ p.price);
                    p.flag = false;
                    p.notifyAll(); // 唤醒生产者去生产
                }else{
                    //产品还没有生产,应该 等待生产者先生产。
                    try {
                        p.wait(); //消费者也等待了...
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        } 
    }
}

//测试类
public class Demo5 {
    
    public static void main(String[] args) {
        Product p = new Product();  //产品
        //创建生产对象
        Producer producer = new Producer(p);
        //创建消费者
        Customer customer = new Customer(p);
        //调用start方法开启线程
        producer.start();
        customer.start();
    } 
}

代码分析：假设生产者拿到锁对象，此时flag为false，生产者生产出苹果对象，flag至为true，此时唤醒消费者消费，然而，在以锁对象p为标识符的线程池中并没有消费者，此时生产者继续持有锁对象，然后发现flag为true，执行wait()方法，此时生产者释放锁对象p，并进入以p为标识符的线程池中等待，此时消费者获取锁，flag为true，消费完毕唤醒以锁对象p为线程池中的等待线程当中的其中一个线程（无法指定唤醒线程），此时生产者被唤醒，此时消费者假设还是持有cpu执行权，继续循环，发现flag为false，进入wait()，释放锁，生产者获取cpu执行权，开始生产….

三、wait()和notify()的使用注意点

1. wait方法与notify方法是属于Object对象的。
理由：若不是Object对象，那么调用者对象即锁对象则必须是线程对象吗？显然不必，锁对象是任意对象。
2. wait方法与notify方法必须要在同步代码块或者是同步函数中才能使用。
理由：如果不存在同步代码块和同步函数则没有锁对象这个概念，而这两个方法必须由锁对象调用。
3. wait方法与notify方法必需要由锁对象调用。
理由：因为需要以锁对象为标识符建立一个线程池，生产者与消费者必须用同一个锁，不同的锁会建立不同的线程池。且不用锁对象调用是报错的，要求就是以锁对象调用，否则就会报错。