Java多线程wait()和notify()方法图解

「爱情、让人受尽委屈。」 2023-09-25 12:35 80阅读 0赞

## 多线程wait()和notify()方法详解 ##

#### 文章目录 ####

*  多线程wait()和notify()方法详解
 *  前言
 *  一、线程间等待与唤醒机制
 *  二、等待方法wait()
 *  三、唤醒方法notify()
 *  四、关于wait和notify内部等待问题（重要）
 *  五、完整代码（仅供测试用）
 *  六、wait和sleep方法的区别（面试题）：
 *  总结

--------------------

## 前言 ##

> 博主个人社区：[开发与算法学习社区][Link 1]
> 
> 博主个人主页：[Killing Vibe的博客][Killing Vibe]
> 
> 欢迎大家加入，一起交流学习~~

--------------------

## 一、线程间等待与唤醒机制 ##

wait()和notify()是**Object类**的方法，用于线程的等待与唤醒，必须搭配**synchronized 锁**来使用。

多线程并发的场景下，有时需要某些线程先执行，这些线程执行结束后其他线程再继续执行。

**比如：** 一个长跑比赛，裁判员要等跑步运动员冲线了才能宣判比赛结束，那裁判员线程就得等待所有的运动员线程运行结束后，再唤醒这个裁判线程。

## 二、等待方法wait() ##

**wait 做的事情:**

*  使当前执行代码的线程进行**等待**. (把线程放到等待队列中)
 *  **释放当前的锁**
 *  满足一定条件时被唤醒, 重新**尝试**获取这个锁.

> wait 要搭配 synchronized 来使用. 脱离 synchronized 使用 wait 会直接抛出异常.

![在这里插入图片描述][b50a9ad0c1f44517b17a523085a31445.png]

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

*  其他线程调用该对象的 **notify 方法**.
 *  wait 等待时间**超时** (wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间).
 *  其他线程调用该等待线程的 **interrupted 方法**, 导致 wait 抛出 InterruptedException 异常.

**注意事项：**

1.  调用wait()方法的前提是**首先要获取该对象的锁（synchronize对象锁）**
2.  调用wait()方法会**释放锁**，本线程进入**等待队列**等待被唤醒，被唤醒后不是立即恢复执行，而是进入**阻塞队列**，**竞争锁**

**等待方法：**

**1.痴汉方法，死等，线程进入阻塞态（WAITING）直到有其他线程调用notify方法唤醒**

![在这里插入图片描述][c833940b9d9a4207bd90a672965978eb.png]

**2.等待一段时间，若在该时间内线程被唤醒，则继续执行，若超过相应时间还没有其他线程唤醒此线程，此线程不再等待，恢复执行。**

![在这里插入图片描述][8e118e56f8c34ea1b8e8a555dc45a535.png]

**调用wait方法之后：**

![在这里插入图片描述][a7f76d1312ad47b28f9a577e6578b2ac.png]

## 三、唤醒方法notify() ##

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

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

**注意事项：**

*  notify():随机唤醒**一个**处在等待状态的线程。
 *  notifyAll():唤醒**所有**处在等待状态的线程。
 *  无论是wait还是notify方法，都需要搭配synchronized锁来使用（等待和唤醒，也是需要对象）

![在这里插入图片描述][096f7309450a479e8544265d3c1df615.png]

## 四、关于wait和notify内部等待问题（重要） ##

对于wait和notify方法，其实有一个**阻塞队列**也有一个**等待队列**。

*  **阻塞队列**表示同一时间只有一个线程能获取到锁，其他线程进入阻塞队列
 *  **等待队列**表示调用wait （首先此线程要获取到锁，**进入等待队列，释放锁**）

**举个栗子：**

现有如下定义的等待线程任务

然后创建三个等待线程：

![在这里插入图片描述][2286fcfcaa524dc6be47020047116d2f.png]

由于**同一时间只有一个线程**（随机调度）能获取到synchronized锁，所以会有两个线程没竞争到锁，从而进入了**阻塞队列**。

这里假如t2先竞争到了锁，所以先会阻塞t1和t3：

![在这里插入图片描述][fb439d71f4a64902a582d8bc2906bccf.png]

又由于调用wait方法会**释放锁**，调用wait方法的线程t2就会进入**等待队列**，直到被notify唤醒或者超时自动唤醒。

![在这里插入图片描述][721fd0bb8fb7458ca87f1066d6b32c13.png]

然后此时lock对象已经被释放了，所以t1和t3 又可以去竞争这个锁了，就从阻塞队列里面竞争锁。

这里假如t3 竞争到了锁，**阻塞队列**只剩下t1：

![在这里插入图片描述][0b0db5ab92464d36a5351d82d3856508.png]

然后t3运行到了wait方法，释放锁，然后进入**等待队列**：

![在这里插入图片描述][5699bfeb2e994922916ec6e4685e9d07.png]

然后重复这些操作~~，最后t1，t2，t3 都进入了**等待队列**中，等待notify线程唤醒（**这里假设notify要放在这些线程start后的好几秒后，因为notify线程也是和这些线程并发执行的，所以等待队列中的线程随时可能被唤醒**）

![在这里插入图片描述][a298e94421124793807aa8695613efb3.png]

**重点来了：**

**在等待队列中的线程，被notify唤醒之后，会直接回到阻塞队列去竞争锁！！！而不是直接唤醒~**

**举个栗子：**

拿notifyAll()来举例，假如此时等待队列中有三个线程t1，t2，t3，那么调用notifyAll()会直接把它们三个直接从**等待队列**中进入到**阻塞队列**中：

![在这里插入图片描述][3150cc25e990416cb1ef54db52d77dd3.png]

然后再去竞争这个锁，去执行wait之后的代码~~

## 五、完整代码（仅供测试用） ##

private static class WaitTask implements Runnable {
        
            private Object lock;
            public WaitTask(Object lock) {
        
                this.lock = lock;
            }
            @Override
            public void run() {
        
                synchronized (lock) {
        
                    System.out.println(Thread.currentThread().getName() + "准备进入等待状态");
                    // 此线程在等待lock对象的notify方法唤醒
                    try {
        
                        lock.wait();
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println(Thread.currentThread().getName() + "等待结束，本线程继续执行");
                }
            }
        }
        private static class NotifyTask implements Runnable {
        
            private Object lock;
            public NotifyTask(Object lock) {
        
                this.lock = lock;
            }
            @Override
            public void run() {
        
                synchronized (lock) {
        
                    System.out.println("准备唤醒");
                    // 唤醒所有线程（随机）
                    lock.notifyAll();
                    System.out.println("唤醒结束");
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            Object lock = new Object();
            Object lock2 = new Object();
            // 创建三个等待线程
            Thread t1 = new Thread(new WaitTask(lock),"t1");
            Thread t2 = new Thread(new WaitTask(lock),"t2");
            Thread t3 = new Thread(new WaitTask(lock),"t3");
           // 创建一个唤醒线程
            Thread notify = new Thread(new NotifyTask(lock2),"notify线程");
            t1.start();
            t2.start();
            t3.start();
            ;
            Thread.sleep(100);
            notify.start();
            // 当前正在执行的线程数
            Thread.sleep(2000);
            System.out.println(Thread.activeCount() - 1);
        }

## 六、wait和sleep方法的区别（面试题）： ##

1.  wait方法是Object类提供的方法，需要搭配synchronized锁来使用，调用wait方法会释放锁，线程进入WAITING状态，等待被其他线程唤醒或者超时自动唤醒，唤醒之后的线程需要再次竞争synchronized锁才能继续执行。
2.  sleep方法是Thread类提供的方法，调用sleep方法的线程进入TIMED\_WAITING状态，不会释放锁，时间到自动唤醒。

## 总结 ##

以上就是多线程场景下wait和notify方法的详解和注意事项了，码字不易，有帮助的话别忘了**关注博主，点赞+收藏哦**~

[Link 1]: https://bbs.csdn.net/forums/killingvibe?joinKey=bxrj0yyjeyrk-2o9q4217kn-1-a7ba228d3f0db23bd3e669796abef74b
[Killing Vibe]: https://blog.csdn.net/qq_43575801
[b50a9ad0c1f44517b17a523085a31445.png]: https://img-blog.csdnimg.cn/b50a9ad0c1f44517b17a523085a31445.png
[c833940b9d9a4207bd90a672965978eb.png]: https://img-blog.csdnimg.cn/c833940b9d9a4207bd90a672965978eb.png
[8e118e56f8c34ea1b8e8a555dc45a535.png]: https://img-blog.csdnimg.cn/8e118e56f8c34ea1b8e8a555dc45a535.png
[a7f76d1312ad47b28f9a577e6578b2ac.png]: https://img-blog.csdnimg.cn/a7f76d1312ad47b28f9a577e6578b2ac.png
[096f7309450a479e8544265d3c1df615.png]: https://img-blog.csdnimg.cn/096f7309450a479e8544265d3c1df615.png
[2286fcfcaa524dc6be47020047116d2f.png]: https://img-blog.csdnimg.cn/2286fcfcaa524dc6be47020047116d2f.png
[fb439d71f4a64902a582d8bc2906bccf.png]: https://img-blog.csdnimg.cn/fb439d71f4a64902a582d8bc2906bccf.png
[721fd0bb8fb7458ca87f1066d6b32c13.png]: https://img-blog.csdnimg.cn/721fd0bb8fb7458ca87f1066d6b32c13.png
[0b0db5ab92464d36a5351d82d3856508.png]: https://img-blog.csdnimg.cn/0b0db5ab92464d36a5351d82d3856508.png
[5699bfeb2e994922916ec6e4685e9d07.png]: https://img-blog.csdnimg.cn/5699bfeb2e994922916ec6e4685e9d07.png
[a298e94421124793807aa8695613efb3.png]: https://img-blog.csdnimg.cn/a298e94421124793807aa8695613efb3.png
[3150cc25e990416cb1ef54db52d77dd3.png]: https://img-blog.csdnimg.cn/3150cc25e990416cb1ef54db52d77dd3.png