【JavaEE】多线程(3) -- 线程等待 wait 和 notify

1. wait()⽅法

2. notify()⽅法

3. notifyAll()⽅法

4. wait 和 sleep 的对⽐（⾯试题）

由于线程之间是抢占式执⾏的, 因此线程之间执⾏的先后顺序难以预知. 但是实际开发中有时候我们希望合理的协调多个线程之间的执⾏先后顺序.

完成这个协调⼯作, 主要涉及到三个⽅法

wait() / wait(long timeout): 让当前线程进⼊等待状态.
notify() / notifyAll(): 唤醒在当前对象上等待的线程.

注意: wait, notify, notifyAll 都是 Object 类的⽅法

1. wait()⽅法

wait 做的事情:

• 使当前执⾏代码的线程进⾏等待. (把线程放到等待队列中)

• 释放当前的锁

• 满⾜⼀定条件时被唤醒, 重新尝试获取这个锁.

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

wait 结束等待的条件:

• 其他线程调⽤该对象的 notify ⽅法.

• wait 等待时间超时 (wait ⽅法提供⼀个带有 timeout 参数的版本, 来指定等待时间).

• 其他线程调⽤该等待线程的 interrupted ⽅法, 导致 wait 抛出 InterruptedException 异常.

public class Test {
    public static void main(String[] args) {
        Object locker = new Object();
        Thread t = new Thread(()->{
            synchronized (locker) {
                System.out.println("wait 等待之前");
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait 等待结束");
            }
        });

        t.start();
    }
}

这样在执⾏到 object.wait() 之后就⼀直等待下去，那么程序肯定不能⼀直这么等待下去了。这个时候就需要使⽤到了另外⼀个⽅法唤醒的⽅法 notify()。

wait提供了两个版本:

2. notify()⽅法

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

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

notify 其实可以不放到 synchronize 里, 不需要先加锁, 但是 java 中特别约定要把 notify 放到 synchronized 里.

代码⽰例: 使⽤notify()⽅法唤醒线程

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

        Thread t2 = new Thread(()-> {
            try {
                Thread.sleep(3000);
                //让 t1 线程有时间进入到wait状态
                synchronized (locker) {
                    System.out.println("t2 notify 之前");
                    locker.notify();
                    System.out.println("t2 notify 之后");
                }
            }catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        t2.start();
    }
}

wait 和 notify 彼此之间是通过 Object 对象联系起来的, 必须是两个对象一致时才能够被唤醒.

3. notifyAll()⽅法

notify⽅法只是唤醒某⼀个等待线程. 使⽤notifyAll⽅法可以⼀次唤醒所有的等待线程.

理解 notify 和 notifyAll

notify 只唤醒等待队列中的⼀个线程. 其他线程还是乖乖等着

notifyAll ⼀下全都唤醒, 需要这些线程重新竞争锁

4. wait 和 sleep 的对⽐（⾯试题）

1. wait 需要搭配 synchronized 使⽤. sleep 不需要.

2. wait 是 Object 的⽅法 sleep 是 Thread 的静态⽅法.

在Java中，wait()和sleep()都是用于线程控制的方法，但是它们有一些重要的区别。

wait()是Object类中定义的方法，而sleep()是Thread类中定义的方法。wait()是在对象级别上进行操作，而sleep()是在当前线程级别上进行操作。

wait()方法会释放线程持有的锁，使线程进入等待状态，直到其他线程调用相同对象上的notify()或notifyAll()方法来唤醒等待的线程。sleep()方法不会释放线程持有的锁。

wait()方法必须在同步上下文中被调用，即在同步方法或同步块中，否则会抛出IllegalMonitorStateException异常。而sleep()方法可以在任何地方调用。

wait()方法还可以指定一个超时时间，在等待超时后会自动唤醒线程。而sleep()方法只能通过interrupt()方法或等待指定时间来唤醒线程。

总的来说，wait()方法用于线程间的协调和通信，而sleep()方法主要用于线程的休眠。wait()方法在等待期间会释放锁，而sleep()方法不会释放锁。