【多线程-从零开始-陆】wait、notify和notifyAll

线程饿死

一个或多个线程因为无法获得执行所需的资源（如CPU时间、锁、或其他同步控制）而被长时间阻塞或延迟执行的情况。尽管这些线程可能处于可执行状态并且已经准备好运行，但由于资源分配的不均衡或调度策略的问题，它们无法获得执行的机会。

例子

你去 ATM 机取钱，在你后面还排了很对人。你进去后，门锁上了，但你发现 ATM 机里面没钱了，于是你出去了。
按理来说，你出来之后，应该轮到排在你后面的人进去了，可你刚把锁打开，前脚刚迈出去，却心想“里面会不会又有钱了？”，于是你又进去了，把门又锁上了，可你进去之后发现还是没钱。
于是你就这样反反复复、进进出出、开锁上锁。虽然你的行为没有造成任何死锁，但你后面的人却做不了任何事（其他线程无法执行任何逻辑），这就叫“线程饿死”

这属于一个概率性问题，和调度器具体的策略直接相关
针对上述问题，同样可以使用 wait / notify 来解决

让你在拿到锁的时候进行判定，判定当前是否执行“取钱”操作，如果能执行，就正常执行；如果不能执行，就需要主动释放锁，并且“阻塞等待”（通过调用 wait），此时这个线程就不会在后续参与锁的竞争了
一直阻塞到“取钱”的条件具备了，此时再由其他线程通过通知机制（notify）唤醒这个线程

wait

因为线程在操作系统上的调度是随机的，而我们不喜欢随机，喜欢确定，所以增加了一些手段来让调度变得确定

多个线程，需要控制线程之间执行某个逻辑的先后顺序，就可以让后执行的逻辑使用 wait，先执行的线程完成某些逻辑后，通过 notify 唤醒对应的 wait
另外通过 wait 和 notify 也是为了解决“线程饿死”问题

当我们尝试使用 wait：

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

运行后，报错了

Monitor：此处指的是 synchronized 这里的锁
合起来为：非法的锁状态异常（加锁状态/未加锁状态）

之所以会出现这种情况，是因为 wait 中会进行一个操作，就是针对 obj 对象，先进行解锁。所以，使用 wait 的时候，务必要放到 synchronized 代码块里面（必须得先加上锁，才能谈“解锁”）
你进入 ATM 机后，发现没钱，就要“阻塞等待”，此时一定是你先解锁，再开门出去。就是先释放锁，再等待。如果你抱着锁等待，就也没把几回让给别人，因为别人也无法进去

并且释放锁和加上锁这两个操作是通过 wait 同时来进行（打包成原子），若不是同时执行，那就可能发生线程切换
比如在释放锁之后，插进来了一个通知正在等待代的线程继续执行操作的线程，可是前面那个才刚刚释放锁，还没开始进行执行等待的操作，最终这个线程由于错过了通知，将持续等待下去

public class Demo3 {  

    public static void main(String[] args) throws InterruptedException {  
        Object obj = new Object();  
        System.out.println("wait 之前");  
        synchronized(obj){  
            obj.wait();  
        }        
        System.out.println("wait 之后");  
    }
}
//打印结果为：wait 之前

因为代码阻塞在中间了，所以后面的逻辑就无法完成，此时线程的状态变成了 WAITING（没有超时时间的等待，有超时时间的事 TIMED_WAITING）
并且由于代码中没有 notify，所以 wait 将一直持续等待下去

综上

wait 使调用的线程进入阻塞
wait 做三件事
1. 释放锁
2. 进入阻塞状态，准备接受通知
3. 收到通知后，唤醒，并且重新尝试获取锁

注意

wait 默认是“死等”，但它还提供了一个带参数的版本，指定超时时间。若 wait 达到了最大时间，还没等到 notify，就不会继续等待了，而是继续执行
wait(1000) 和 sleep(1000) 还是有本质区别的
- 使用 wait 的本质目的是为了提前唤醒，而 sleep 就是固定时间的阻塞，不涉及唤醒（虽然 sleep 可以被 Interrupt 唤醒，但这是一个终止线程的操作，而不是唤醒）
- wait 必须要搭配 synchronized 使用，并且 wait 会先释放锁，同时进行等待
- sleep 和锁无关，如果不加锁，sleep 可以正常使用；如果加了锁，sleep 操作不会释放锁，会“抱着锁”，一起睡，其他线程无法拿到锁

notify唤醒wait的操作

public class Demo5 {  
    private static Object locker = new Object();  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(() -> {  
            synchronized (locker){  
                System.out.println("t1 wait之前");  
                try {  
                    locker.wait();  
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }                System.out.println("t1 wait之后");  
            }        
        });        
        Thread t2 = new Thread(() -> {  
            System.out.println("t2 notify之前");  
            Scanner scanner = new Scanner(System.in);  
            scanner.next(); //此处是通过这个next构造一个“阻塞”的状态  
  
            synchronized (locker) {  
                locker.notify();  
            }            
            System.out.println("t2 notify之后");  
        });        
        t1.start();  
        t2.start();  
    }
}
//运行结果：
t1 wait之前
t2 notify之前
9
t2 notify之后
t1 wait之后

要保证加锁的对象和调用 wait 的对象是一样的，如果不是同一个对象，那么无法使用，因为锁的状态是不对的
要确保调用 wait 和 notify 的对象是一样的才能唤醒
wait 和 notify 调用前都要加上锁
- 因为在多线程中，一个线程加锁，一个不加，是无意义的，不会有任何的阻塞效果。此处希望 t2 执行 notify 的时候，t1 是未持有锁的状态，如果 t1 正持有锁，肯定就不是在 wait，这个时候去 notify 也没有意义。所以要确保 notify 拿到锁，再去 notify 唤醒 wait
一定要确保持有锁才能谈释放
- 假设是多个现场，如果多个线程都在同一个对象上 wait，notify 只会随机唤醒其中一个

notifyAll

和 notify 相对，还有一个 notifyAll

将上面的notify换成notifyAll之后
运行结果为：
---
t1 wait之前
t3 wait之前
t2 wait之前
9
t4 notifyAll之前
t4 notifyAll之后
t1 wait之后
t2 wait之后
t3 wait之后

大部分情况下，都是使用 notify。若要唤醒多个，就一个一个地唤醒，整个程序执行过程是比较有序的，如果一下全唤醒，这些被唤醒的线程就会无序的竞争锁（会很混乱，可能带来未知的风险）
notify 和 notifyAll 通知的时候，如果没有线程在 wait，不会有任何副作用

练习

创建三个线程，使用 wait 和 notify 控制先后打印 A、B、C 三个字母

public class Demo6 {  
    private static Object locker = new Object();  
    private static Object locker2 = new Object();  
  
    public static void main(String[] args) {  
        Thread t1 = new Thread(() -> {  
            System.out.println("A");  
            //Thread.sleep(1000);
            synchronized (locker) {  
                locker.notify();  //这个notify用来唤醒t2中的wait，因为是locker锁
            }        
        });        
        Thread t2 = new Thread(() -> {  
            synchronized (locker) {  
                try {  
                    locker.wait();  //被t1的notify唤醒
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }                
                System.out.println("B");  
  
                synchronized (locker2){  
                    locker2.notify();  //这个notify用来唤醒t3中的wait，因为是locker2锁
                }            
            }        
        });        
        Thread t3 = new Thread(() -> {  
            synchronized (locker2) {  
                try {  
                    locker2.wait();  //被t2的notify唤醒
                } catch (InterruptedException e) {  
                    throw new RuntimeException(e);  
                }            
            }            
            System.out.println("C");  
        });        
        t1.start();  
        t2.start();  
        t3.start();  
    }
}

这个代码中，若是先执行 t2 的 wait，后执行 t1 的 notify，代码逻辑就一切顺利（大概率就是这样，因为 t1 的打印需要不少时间）
但存在这样的可能：t1 限制性了打印和 notify，然后 t2 才执行 wait，意味着通知来早了，t2 错过了通知，t2 的 wait 就无人唤醒了
为了解决这样的情况，我们只需要在 t1 里面加一个 sleep 就可以了 (只要在锁的前面就行)，让 t1 线程等一会，其他线程先执行