java EE初阶 — wait 和 notify

系统管理员 2023-10-02 23:36 4阅读 0赞

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

*  1.wait 和 notify
 *   *  1.1 wait()方法
     *  1.2 notify()方法
     *  1.3 notifyAll()方法

## 1.wait 和 notify ##

线程最大的问题是抢占式指向，随机调度。而写代码的时候，确定的东西会比较好。

于是就有程序猿发明了一些办法，来控制线程之间的执行顺序。  
虽然线程在内核里的调度是随机的，但是可以通过一些 API 然线程主动阻塞，主动放弃 CPU。（给别的线程让路）

比如，t1 t2 两个线程，希望 t1 先干活，干的差不多的时候，再让 t2 来干。  
就可以让 t2 **wait** 。（阻塞，主动放弃 CPU）

上面的场景，使用 **join** 和 **sleep** 无法做到。  
使用 jion 则必须要 t1 彻底执行完毕，t2 才可以运行。  
如果是希望 t1 先干50%的活，就让 t2 开始行动，join 无能为力。  
使用 sleep 指定一个休眠时间，但是 t1 执行的这些活，到底花了多少的时间，不好估计。

于是就可以使用 **wait** 和 **notify**。  
  
**wait**、**notify**、**notifyAll** 这几个类，都是，Object类中的方法。

### 1.1 wait()方法 ###

**wait** 的作用是进行阻塞。

当某个线程调用 wait 方法时，就会进入阻塞（无论是通过哪个对象 wait 的）。  
此时的状态就处在 **WAITING**

先来看一段代码。

package thread;
    
    public class ThreadDemo18 {
        
        public static void main(String[] args) throws InterruptedException{
        
            Object object = new Object();
                object.wait();
            }
        }
    }

**throws InterruptedException**  
有很多带阻塞功能的方法都有这个异常。  
这些方法都是可以被 **interrupt** 方法通过这个异常唤醒。

**wait** 不加任何参数就会一直等待，直到有其他的线程唤醒它。

上面的代码会抛一个异常。

![564f45db90af4ee6b749a81086618268.png_pic_center][]  
这是一个**非法的锁状态异常**。

锁的状态：**被加锁的状态和解锁的状态。**

wait 的操作分为：

1.  先释放锁。
2.  进行阻塞等待
3.  收到通知之后，重新尝试获取锁，并且在获取锁之后继续往下执行。

这里的锁的状态异常，就是没加锁，就要要释放锁了。

解决办法就是搭配 **synchronized** 来使用。

package thread;
    
    public class ThreadDemo18 {
        
        public static void main(String[] args) throws InterruptedException{
        
            Object object = new Object();
            synchronized (object) {
        
                System.out.println("wait之前");
                object.wait();
                System.out.println("wait之后");
            }
    
        }
    }

![96ea463b127048e98486fc9228e76482.png_pic_center][]  
  
虽然这里的 **wait** 是阻塞在 synchronized 代码块里了，  
但是实际上，这里的阻塞是释放了锁的。  
此时其他线程是可以获取到 object 这个对象的锁的。

此时这里的阻塞就处于 **WAITING**

### 1.2 notify()方法 ###

**notify** 方法是唤醒等待的线程。  
  
来看一段代码

package thread;
    
    public class ThreadDemo19 {
        
        public static void main(String[] args) {
        
            Object object = new Object();
            Thread t1 = new Thread(() -> {
        
                //线程1负责进行等待
                System.out.println("t1 wait之前");
                try {
        
                    synchronized (object) {
        
                        object.wait();
                    }
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println("t1 wait之后");
            });
    
            Thread t2 = new Thread(() -> {
        
                //线程2负责唤醒
                System.out.println("t2 notify之前");
                    synchronized (object) {
        
                        object.notify();
                    }
                System.out.println("t2 notify之后");
            });
            t1.start();
            try {
        
                Thread.sleep(500);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            t2.start();
        }
    }

![b1f84d1cdffb4b0ea214499702f95b02.png_pic_center][]  
此处，先执行了 **wait** 很明显 操作阻塞了，没有看到 wait 之后的打印。  
接下来执行到了 t2 ，t2 进行了 notify 的时候，才会把 t1 的 wait 唤醒，t1 才能继续执行。  
  
此处的通知和 **wait** 配对。  
如果 **wait** 使用的对象和 **notify** 使用的对象不同。  
此时的 notify 不会有任何效果。（notify 只能唤醒在同一个对象上等待的线程）  
  
如果的代码这里写作：**t1.start** 和 **t2.start**  
由于线程不确定性，此时不能保证是先执行 **wait**，后执行 **notify**。

如果调用 notify 此时没有 wait 。此处的 wait 是无法被唤醒的。  
因此此处的代码要求保证先执行 **wait** 后执行 **notify**，这样才是有意的。

wait 和 sleep 的区别  
**wait** 的带有时间的版本看起来就和 **sleep** 有点像。  
但是其实还是有区别的，虽然都是可以指定等待的时间，也都能被提前唤醒，  
（wait 是被 nottify 唤醒，sleep 是被 interrupt 唤醒）  
但是这里表示的含义截然不同。

*  notify 唤醒 wait 是不会有任何异常的。（正常的业务逻辑）
 *  interr 唤醒 sleep 则是会出现异常。（表示一个出问题的逻辑）

下面看一道练习：

有三个线程，输出字母 ABC，控制三个线程分别按照 ABC 的顺序打印出来。

package thread;
    
    public class ThreadDemo20 {
        
        //有三个线程，控制三个线程分别按照 ABC 的顺序打印出来
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                System.out.println('A');
            });
    
            Thread t2 = new Thread(() -> {
        
                System.out.println('B');
            });
    
            Thread t3 = new Thread(() -> {
        
                System.out.println('C');
            });
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

因为它的结果是随机调度的因此不能确定先输出哪个，结果可能是 ABC，也可能是ACB，或者是其他的结果。  
  
![93f288af3f904753a1917adc80ddedbf.png_pic_center][]  
  
我们需要通过 wait 和 notify 告知 线程1 在打印完A之后通知线程2可以打印B了  
要保证线程2要阻塞到A打印结束，才会开始打印B。  
线程3也是同理，直到按照顺序打印结束是会出现 ABC。  
  
  
下面是优化过的版本。

package thread;
    
    public class ThreadDemo20 {
        
        //有三个线程，控制三个线程分别按照 ABC 的顺序打印出来
        public static void main(String[] args) throws InterruptedException{
        
            Object locker1 = new Object();
            Object locker2 = new Object();
    
            Thread t1 = new Thread(() -> {
        
                System.out.println('A');
                synchronized (locker1) {
        
                    //告知线程2B可以打印了
                    locker1.notify();
                }
            });
    
            Thread t2 = new Thread(() -> {
        
                //等待线程1打印完A再打印B
                synchronized (locker1) {
        
                    try {
        
                        locker1.wait();//等待
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                System.out.println('B');
                synchronized (locker2) {
        
                    //告知线程3C可以打印了
                    locker2.notify();
                }
            });
    
            Thread t3 = new Thread(() -> {
        
                synchronized (locker2) {
        
                    try {
        
                        locker2.wait();//等待
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                System.out.println('C');
            });
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

通过 wait 和 notify 来实现三个线程之间相互等待和通知的作用。  
  
![8408a474b1594c38928bba59e5cc8672.png_pic_center][]  
c此时就是预期好的顺序了。  
  
但是这样还是会有一些小问题：

**如果是先执行线程2的 notify 后执行线程2的 wait ，此时程序就会僵住**  
  
解决办法就是 **保证线程1的启动速度要慢于线程2和线程3**

关键代码如下：

t2.start();
     t3.start();
     Thread.sleep(1000);
     t1.start();

调整完线程1的顺序后，再加一个睡眠时间 1000 ms。

### 1.3 notifyAll()方法 ###

**notify** 只能唤醒某一个等待线程，而 **notifyAll** 可以唤醒所有的等待线程。  
  
  
**注意：**

虽然是同时唤醒多个线程, 但是这多个线程都需要竞争锁. 所以并不是同时执行, 而仍然是有先有后的执行。

![87f0589c9efd49f5ae7ae30549fe37ef.png_pic_center][]  
这是 **notify** 只能唤醒一个。  
  
![8d123e5b36614cbaa31f28a5e7725be0.png_pic_center][]  
这是 **notifyAll** 可以换线多个线程，但是多个线程需要竞争一把锁。

[564f45db90af4ee6b749a81086618268.png_pic_center]: https://img-blog.csdnimg.cn/564f45db90af4ee6b749a81086618268.png#pic_center
[96ea463b127048e98486fc9228e76482.png_pic_center]: https://img-blog.csdnimg.cn/96ea463b127048e98486fc9228e76482.png#pic_center
[b1f84d1cdffb4b0ea214499702f95b02.png_pic_center]: https://img-blog.csdnimg.cn/b1f84d1cdffb4b0ea214499702f95b02.png#pic_center
[93f288af3f904753a1917adc80ddedbf.png_pic_center]: https://img-blog.csdnimg.cn/93f288af3f904753a1917adc80ddedbf.png#pic_center
[8408a474b1594c38928bba59e5cc8672.png_pic_center]: https://img-blog.csdnimg.cn/8408a474b1594c38928bba59e5cc8672.png#pic_center
[87f0589c9efd49f5ae7ae30549fe37ef.png_pic_center]: https://img-blog.csdnimg.cn/87f0589c9efd49f5ae7ae30549fe37ef.png#pic_center
[8d123e5b36614cbaa31f28a5e7725be0.png_pic_center]: https://img-blog.csdnimg.cn/8d123e5b36614cbaa31f28a5e7725be0.png#pic_center