【Java EE初阶五】wait及notify关键字

news2024/12/23 15:25:12

1. wait和notify的概念

所谓的wait和notify其实就是等待、通知机制；该机制的作用域join类似；由于多个线程之间是随机调度的，引入wait和notify就是为了能够从应用层面上，干预到多个不同线程代码的执行顺序，此处的干预，不是影响系统的线程调度策略（内核里调度线程任然是无序调度）；

简单来说就是在应用程序代码中，让后执行的线程，主动放弃被调度的机会，就可以让先执行的线程，先把对应的代码执行完成；

2. wait和notify的作用

2.1 例子引入

        现在有很多人要去ATM里，其中A是取钱，B是存钱的，C是运钞票的工作人员，负责给ATM机补充钱，防止ATM机没钱了，别人取不到钱。

        而这里的A，B，C被当做是线程，每次去ATM机里，只能有一个人进去，相当于上锁了，其他人不能进去，且处于被阻塞等待的状态，等ATM机里面的人完成操作出来后，别的人才能进去，但是这里是多线程随机调度的原因，其他线程会有锁竞争。

其中当A进去ATM机里后，就上锁，其他人不能进去；

从线程调度执行的角度来看，如果把A比作是线程，当A线程进去后就会上锁，A线程要进行取钱的操作，其他线程不能进去操作，当A线程执行完自己的操作后，其他线程才能去锁竞争。

        但是如果ATM机里面没有钱时，A线程就不能完成取钱这个操作，它会退出ATM机，但退出后呢，它就因为没有取到钱而想继续进去ATM里面取钱，从而完成完成取钱这个操作；

        但是A依旧就会继续和其他线程进行锁竞争，又因为A线程之前拿到了锁，处于RUNNABLE状态（本来就轮到A取），其他线程因为阻塞，处于BLOCKED状态，需要被系统唤醒后，才能去竞争锁；

总体来说，在ATM中依旧没有钱，线程A不用唤醒就能去竞争锁，所以A线程拿到锁的可能性还是很大的。但是如果这样子，那线程A频繁的在ATM门口反复横跳，始终占据的锁很长时间，导致其他线程（包括给ATM机送钱的线程）也不能进去操作，这样也就出现线程安全问题了。对于其他线程，始终无法拿到锁，这个情况称为 “线程饿死”。

上述所说的线程A的代码大概逻辑是这样的：

        当A线程没有取到钱，就会一直重复加锁，解锁的操作。虽然这样的bug没有死锁那么严重，但也是要解决的。这时，就可以用wait和notify机制期望改进成如下图逻辑所示的效果：

这里的wait内部做了三件事

（1）释放锁，给其他线程竞争锁

（2）进入阻塞等待，让及时需要操作的线程运行

（3）等其他线程使用notify后，解除wait，参与到锁竞争中

2.2 wait和notify的使用

wait的使用前提必须是当前对象被上锁了才能使用，不能你对象没被上锁，就wait了，那也不知道是在wait谁。

有线程wait后，也必须有其他线程notify来释放这个wait，不然这个wait就会一直阻塞。

2.2.1 没有上锁的wait

代码如下：

package thread;


public class ThreadDemo29 {
    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        locker.wait();
    }
}

结果如下：

2.2.2 当一个线程被wait，但没有其他线程notify来释放这个wait

代码如下：

package thread;


public class ThreadDemo29 {

        public static void main(String[] args) {
            Object locker = new Object();
            Thread t1 = new Thread(() -> {
                synchronized (locker) {
                    System.out.println("wait之前");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("wait之后");
                }
            });
            t1.start();
        }
}

结果如下：

当前锁对象在进行wait之后，没有在主线中使用notify来唤醒，导致该线程t1一在处于阻塞状态；

2.2.3 两个线程，有一个线程wait，有一个线程notify来释放wait

代码如下：
package thread;


public class ThreadDemo29 {
        public static void main(String[] args) {
            Object locker = new Object();
            Thread t1 = new Thread(() -> {
                synchronized (locker) {
                    System.out.println("t1 wait之前");
                    try {
                        locker.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("t2 wait之后");
                }
            });
            Thread t2 = new Thread(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                synchronized (locker) {
                    System.out.println("t2 notify之前");
                    locker.notify();
                    System.out.println("t2 notify之后");
                }
            });
            t1.start();
            t2.start();
        }
}
结果如下：

我们代码里释放wait的notify，用的锁对象必须是要一样的，如果不一样，wait是不能被释放的，t1也就不能被唤醒了.

在系统中，notify可以不用上锁，但是在java中，规定了要上锁，而且上锁的对象也要和notify对象一样，所以和系统是有区别的。

结果具体分析：

结果解析：

t1 和 t2 执行的时候：

1、因为t1 sleep了1秒，所以能保证t1 先wait，所以先打印 “t1 wait之前”，这时，t1就进入阻塞等待状态。

2、t2线程sleep了1秒后，获得这个locker锁，打印“t2 notify 之前”，当t2线程执行了notify后，t1 线程的wait就被释放了。

3、因为t2还在持有锁，所以t1会还会进入阻塞，t2打印 “t2 notify之后” ，释放锁。

4、t1拿到锁，再打印“t1 wait之后”。