博客

wait和notify是用来处理线程调度随机性的问题，


不喜欢随机性，需要让彼此之间有一个固定的顺序，例如传球、上篮。

wait和notify都是Object对象的方法，调用wait方法的线程，就会陷入阻塞，阻塞到其他线程通过notify来通知。

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

为什么会这样？

wait内部会做三件事：

• 1、先释放锁
• 2、等待其他线程的通知
• 3、收到通知之后，重新获取锁，并继续执行下去

因此要想使用wait/ notify，就得搭配 synchronized

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

wait 哪个对象，就得针对哪个对象加锁

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

        Thread t2 = new Thread(() -> {
            //进行 notify
            synchronized (locker){
                System.out.println("notify 之前");
                locker.notify();
                System.out.println("notify 之后");
            }
        });
        t2.start();
    }
    public static void main2(String[] args) throws InterruptedException {
        Object object = new Object();
        synchronized (object){
            System.out.println("wait 前");
            object.wait();
            System.out.println("wait 后");
        }
    }

wait notify 都是针对同一个对象来操作的

例如现在有一个对象o。有10个线程，都调用了o.wait，此时10个线程都是阻塞状态，如果调用了 o.notify ，就会把10个其中的一个给唤醒(唤醒哪个不确定)，针对 notifyAll，就会把所有的10个线程都给唤醒， wait 唤醒之后，会重新尝试获取到锁(这个过程就会发生竞争)，


相对来说，更常用的还是 notify.