JAVA多线程三（线程间通信：wait、notify运用，生产者消费者问题）

目录

一、为什么要处理线程间通信

二、等待唤醒机制

三、生产者消费者问题

举例：

分析：

案例：

四、区分sleep()和wait()

五、是否释放锁

释放锁的操作

不会释放锁的操作

---

一、为什么要处理线程间通信

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，但B线程必须等A线程生产包子才能吃包子，那么线程A与线程B之间就需要线程通信—— 等待唤醒机制。

即：当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。  

二、等待唤醒机制

在一个线程满足某个条件时，就进入等待状态（wait() / wait(time)）， 等待其他线程执行完他们的指定代码过后再将其唤醒（notify()）;或可以指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，如果需要，可以使用 notifyAll()来唤醒所有的等待线程。wait/notify 就是线程间的一种协作机制。

我们先来了解Object类的等待和唤醒方法

方法名	说明
void wait()	线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态是 WAITING 或 TIMED_WAITING。它还要等着别的线程执行一个特别的动作，也即“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
void notify()	唤醒正在等待对象监视器wait set中的单个线程
void notifyAll()	唤醒正在等待对象监视器wait set中的所有线程

public class Eg4 extends Thread{
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        new Thread(()->{
            //细节1：wait方法与notify方法必须要由同一个锁对象调用。
            //因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。
            synchronized (lock) {
                        try{
                            System.out.println("wait 之前->");
                            //细节2：wait方法与notify方法是属于Object类的方法的。
                            //因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。
                            lock.wait();
                            System.out.println("wait 之后->");
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
            }
            }).start();
        Thread.sleep(500);
        //细节3：wait方法与notify方法必须要在`同步代码块`或者是`同步函数`中使用。
        //因为：必须要`通过锁对象`调用这2个方法。否则会报java.lang.IllegalMonitorStateException异常.
        synchronized (lock){
            System.out.println("notify 操作后->");
            lock.notify();
        }
    }
}

运行后输出： 

wait 之前->

notify 操作后->

wait 之后->

注意：

被通知的线程被唤醒后也不一定能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以它需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：

• 如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；

• 否则，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态

 三、生产者消费者问题

举例：

生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。

类似的场景，比如厨师和服务员等。

生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

分析：

包含了两类线程：

• 一类是生产者线程用于生产数据
• 一类是消费者线程用于消费数据

为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

隐含了两个问题：

• 线程安全问题：因为生产者与消费者共享数据缓冲区，产生安全问题。不过这个问题可以使用同步解决。

• 线程的协调工作问题：

  • 要解决该问题，就必须让生产者线程在缓冲区等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。同样，也可以让消费者线程在缓冲区空时进入等待(wait)，暂停进入阻塞状态，等到生产者往缓冲区添加数据之后，再通知(notify)正在等待的线程恢复到就绪状态。通过这样的通信机制来解决此类问题。

 案例：

生产者消费者案例中包含的类：

箱类(Box)：定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作

生产者类(Producer)：实现Runnable接口，重写run()方法，调用存储牛奶的操作

消费者类(Customer)：实现Runnable接口，重写run()方法，调用获取牛奶的操作

测试类(BoxDemo)：里面有main方法，main方法中的代码步骤如下

①创建箱对象，这是共享数据区域

②创建消费者对象，把箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作

③创建生产者对象，把箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作

④创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递

⑤启动线程

public class Box extends Thread{
    //定义一个成员变量，表示第x瓶奶
    private int milk;

    //提供存储牛奶和获取牛奶的操作
    public synchronized void put(int milk) {
        //如果有牛奶，等待消费
        if(this.milk!=0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk = milk;

        System.out.println("生产了" + this.milk + "瓶奶放入奶箱");

        //唤醒其他等待的线程
        this.notifyAll();
    }

    public synchronized void get() {
        //如果没有牛奶，等待生产
        if(this.milk == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第" + this.milk + "瓶奶");

        //每次消费一瓶
        this.milk--;
        //唤醒其他等待的线程
        this.notifyAll();
    }
}

public class Customer implements Runnable{
    private Box b;

    public Customer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        while (true) {
            b.get();
        }
    }
}

public class Producer implements Runnable{
    int n1 = 2;//每次生产2瓶
    int n2 = 3;//假设只供应3次
    public int getCount(){
        return n1 * n2;//返回共生产多少
    }
    private Box b;

    public Producer(Box b) {
        this.b = b;
    }

    @Override
    public void run() {
        //供应3次牛奶
        for(int i=1; i<=n2; i++) {
            b.put(n1);
        }
    }
}

public class BoxDemoTest {
    public static void main(String[] args) {
        //创建奶箱对象，这是共享数据区域
        Box b = new Box();

        //创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
        Producer p = new Producer(b);
        //创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
        Customer c = new Customer(b);

        //创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
        Thread t1 = new Thread(p);
        Thread t2 = new Thread(c);

        //启动线程
        t1.start();
        t2.start();
        System.out.println("共供应"+p.getCount()+"瓶牛奶");
    }
}

运行结果： 

共供应6瓶牛奶

生产了2瓶奶放入奶箱

用户拿到第2瓶奶

用户拿到第1瓶奶

生产了2瓶奶放入奶箱

用户拿到第2瓶奶

用户拿到第1瓶奶

生产了2瓶奶放入奶箱

用户拿到第2瓶奶

用户拿到第1瓶奶

四、区分sleep()和wait()

相同点：一旦执行，都会使得当前线程结束执行状态，进入阻塞状态。

不同点：

① 定义方法所属的类：sleep():Thread中定义。 wait():Object中定义

② 使用范围的不同：sleep()可以在任何需要使用的位置被调用； wait():必须使用在同步代码块或同步方法中

③ 都在同步结构中使用的时候，是否释放同步监视器的操作不同：sleep():不会释放同步监视器 ;wait():会释放同步监视器

④ 结束等待的方式不同：sleep()：指定时间一到就结束阻塞。 wait():可以指定时间也可以无限等待直到notify或notifyAll。

五、是否释放锁

任何线程进入同步代码块、同步方法之前，必须先获得对同步监视器的锁定，那么何时会释放对同步监视器的锁定呢？

释放锁的操作

1. 当前线程的同步方法、同步代码块执行结束。
2. 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致当前线程异常结束。
4. 当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起，并释放锁。

不会释放锁的操作

• 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
• 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该该线程挂起，该线程不会释放锁（同步监视器）。

• 应尽量避免使用suspend()和resume()这样的过时来控制线程。