等待和通知

朱雀 2024-02-05 13:23 25阅读 0赞

## 引入 ##

由于线程是抢占式执行的,因此线程之间的执行的先后顺序难以预知

但是实际开发中我们希望合理协调多个线程之间执行的先后顺序.

> **这里的干预线程先后顺序,并不是影响系统的调度策略(内核里调度线程,仍然是无序调度).**
> 
> **就是相当于在应用程序代码中,让后执行的线程主动放弃被调度的机会.就可以让执行线程,先把对应的代码执行完了**.

完成这个协调工作,主要涉及到三个方法

wait()/wait(long timeout):让当前线程进入准备状态.

notify()/notifyAll():唤醒在当前对象上等待的线程.

> 注意:wait,notify,notifyAll都是Object类的方法.

## wait()方法 ##

> 一个线程重复拿到锁,别的线程无法拿到锁,这个情况称为"线程饿死/饥饿".属于概率性事件.虽然不像死锁那样严重.这种情况确实是bug.没那么严重,但也极大地影响了程序的运行.
> 
> 处理:使该线程主动放弃对锁的争夺/放弃去cpu调度执行(进入阻塞,也就是wait).一直到这个条件具备,再解除阻塞,参与锁竞争.

**wait做的事情:**

> **1.使当前执行代码的线程进行等待.(把线程放到等待队列中).**
> 
> **2.释放当前的锁.**
> 
> **3.满足一定条件时被唤醒,重新尝试获取这个锁**.
> 
> 其中,1,2条可以让其他线程有机会拿到锁了.第三条指当其它线程调用notify的时候,wait解除阻塞.

**wait结束等待的条件:**

> **1.其它线程调用该对象的notify方法.**
> 
> **2.wait等待时间超时(wait方法提供一个带有timeout参数的版本,来指定等待时间)->这是为了防止死等,具有鲁棒性**
> 
> **3.其它线程调度该等待线程的interrupted方法,导致wait抛出InterruptException异常.**

观察wait()方法的使用:

public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        synchronized (object) {
            System.out.println("等待中");
            object.wait();
            System.out.println("等待结束");
        }
    }

这样执行到object.wait()之后就会一直等待下去,那么程序肯定不能这样一直等待下去了.这个时候就需要使用到了另外一个方法以唤醒,也就是notify().

## notify方法 ##

notify方法是唤醒等待的线程.

>  **1.方法notify()也要在同步方法或同步块中调用,该方法是用来通知那些可能等待该对象的对象锁的其它线程,对其发出通知notify,并使它们重新获取该对象的对象锁.**
> 
> **2.如果有多个线程等待,则有线程调度器随机挑选出一个呈wait状态的线程.(前提是操作的是同一个锁).并没有"先来后到"**
> 
> **3.在notify()方法后,当前线程不会马上释放该对象锁,要等到执行notify()方法的线程将程序执行完,也就是退出同步代码块之后才会释放对象锁.**

代码示例:

public class ThreadTest5 {
        public static Object locker = new Object();
    
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> {
               synchronized (locker) {
                   System.out.println("t1 wait 之前");
                   try {
                       //t1执行起来之后,执行到这,就会先立即释放锁,进入wait方法(释放锁+阻塞等待)
                       locker.wait();
                       System.out.println("t1 wait 之后");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            });
    
            Thread t2 = new Thread(() -> {
                try {
                    //t2执行起来之后,先进行sleep(3000)(这个sleep操作就可以让t1先拿到锁)
                    //如果先notify虽然不会有副作用(不会出现异常之类的),但是wait就无法被唤醒,逻辑上有问题
                    Thread.sleep(3000);
                    //t2sleep结束之后,由于t1是wait状态,t2就能拿到锁
                    //接下来打印t2notify之前,执行notify操作,这个操作就能唤醒t1(此时t1就从WAITING状态恢复过来了)
                    synchronized (locker) {
                        System.out.println("t2 notify 之前");
                        locker.notify();
                        //但是由于t2此时还没有释放锁,WAITING恢复之后,尝试获取锁,就可能出现一个小小的阻塞,这个阻塞是由锁竞争引起的
                        //t1目前处于BLOCKED状态,但是时间比较短,肉眼看不见
                        System.out.println("t2 notify 之后");
                    }
                    //t2释放锁之后,就可以继续执行t1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t1.start();
            t2.start();
        }
    }

## notifyAll()方法 ##

notify方法只是唤醒某一个等待线程.使用notifyAll方法可以一次唤醒所有的等待线程.

> **但是注意,这些线程在wait返回时,要重新获取锁,就会因为锁的竞争,使这些线程实际上是一个一个串行执行的(谁先谁后拿到锁是不一定的).**

理解notify和notifyAll

> **notify只唤醒等待队列中的一个线程.其它线程还是乖乖等着**
> 
> **notifyAll一下全都唤醒,需要这些线程重新竞争锁.**
> 
> 相比之下,还是更倾向于notify.因为notifyAll全部唤醒之后,不好控制

## wait和sleep的对比 ##

其实理论上wait和sleep完全是没有可比性的,因为一个是用于线程之间通信的,一个是让线程阻塞一段时间,唯一的共同的就是都可以让线程放弃执行一段时间.

> **1.wait可通过notify唤醒,sleep通过Interrupt唤醒**
> 
> **2.使用wait的最主要的目标,一是不知道夺少时间的前提下使用的.所谓的"超时间",就是"兜底"**
> 
> **使用sleep,一定是直到多少时间的前提下使用的,这个操作不因该作为正常业务逻辑(通过异常唤醒,说明程序应该是出现特殊情况了)**
> 
> **3.wait搭配synchronized使用,sleep不需要**
> 
> **4.wait是Object的方法,sleep是Thread的静态方法**