wait 和 notify

最新推荐文章于 2024-09-27 00:45:01 发布

楠枬

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量1.2k

点赞数 68

分类专栏： JavaEE 文章标签： java 开发语言多线程

本文链接：https://blog.csdn.net/2301_76161469/article/details/141215712

版权

JavaEE 专栏收录该内容

36 篇文章 1 订阅

订阅专栏

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

例如：

在篮球场上，每个队员都是独立的执行流，也就是一个线程

当需要完成一个具体的得分动作时，就需要多个队员相互配合，按照一定的顺序执行一定的动作，线程 1 先向线程 2 "传球"，线程2 才能 "扣篮"

要完成协调工作，主要涉及到三个方法：

wait()/wait(long timeout)：让当前线程进入等待状态

notify()：唤醒当前对象上等待的线程

notifyAll()：唤醒当前对象上所有等待的线程

接下来，我们就来学习这三个方法，我们首先来看 wait 方法

wait() 方法

我们先来看一个例子：

一个柜子里有食物，5个人（线程）共同使用这个柜子，并从里面拿取食物（假设同一时间只能一人拿取），1号先使用这个柜子（对其进行加锁），但是当1号打开这个柜子时发现柜子里没有食物，此时1号就会关上柜门（释放锁），等有食物时再来拿

此时，其他人就会竞争这个锁，争取使用柜子，而刚刚释放锁的1号，也会参与到锁竞争中，因此，也就有可能刚刚释放锁的1号又重新拿到锁，并且，由于1号离得近（1号线程处于 RUNNABEL 状态，其他线程处于 BLOCKED 状态），他就有很大可能再次拿到锁

1号又拿到锁，发现没有食物，又释放锁，又竞争到锁，发现没有食物，又释放锁......

如此重复，就会导致1号反复获取到锁，但是又不能完成实质性的操作；而其他线程，则无法拿到锁。这种情况，称之为 线程饿死（线程饥饿）

线程饿死这样的情况，属于概率性事件（1号拿到锁的概率更大，但是其他线程也有可能会拿到锁），不像死锁，一旦出现后，就一定会阻塞，但线程饥饿这样的情况，也极大可能会影响其他线程的运行

因此，我们就需要对这种情况进行处理：

线程饿死出现的关键在于：1号发现自己要执行逻辑的前提条件不具备（柜子中没有食物）时，就应该主动放弃对锁的竞争，主动放弃去 CPU 上调度执行，即，进入阻塞状态，一直等待前提条件具备了（其他线程往柜子中放了食物），此时再解除阻塞，参与到锁竞争中

此时，就可以使用 wait 进行等待：

让 1号判断前提条件是否满足，若不满足，则 wait 等待

其他线程让条件满足后，再通过 notify 来唤醒 1号

接下来，我们就通过具体的代码来学习 wait 的使用：

我们让 t1 线程进入等待：

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

        t1.start();

    }
}

此时，观察运行结果，发现抛出了异常 IllegalMonitorStateException

为什么会抛出异常呢？

这是因为 wait 必须搭配 synchronized 来使用

wait 做的事情有：

1. 使当前执行代码的线程进行等待（将线程放到等待队列中）

2. 释放当前锁

3. 满足一定条件时被唤醒，重新尝试获取到这个锁

wait 要对当前锁进行释放，释放锁的前提，是要先拿到锁，因此 wait 必须放到 synchronized 中使用

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

        t1.start();

    }
}

wait、sleep 和 join，都有可能被 interrupt 提前唤醒，都需要处理异常

每个对象里都有一把锁，调用 wait 的对象，必须和 synchronized 中的锁对象是一致的，wait 解除的锁是 locker对象的锁，后续 wait 被唤醒后，重新获取到锁，当然也是获取到 locker 对象的锁

此时，t1 线程就在 wait 这里阻塞了：

我们使用 jconsole 来观察 t1 线程的状态：

此时，线程进入 WAITING 状态

而 wait 结束等待的条件为：

1. 其他线程调用该对象的 notify 方法

2. wait 等待时间超时（wait 方法提供了带有 timeout 参数的版本，用来指定等待最长时间）

3. 其他线程调用该等待线程的 interrupt 方法，导致 wait 抛出 InterruptedException 异常

接下来，我们就来学习 notify() 方法，来唤醒等待中的线程

notify() 方法

notify() 方法用于唤醒等待的线程

我们在 t2 线程中唤醒 t1 线程：

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

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            locker.notify();
        });

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

此时抛出异常 IllegalMonitorStateException

这是因为 Java 中约定 notify 也需要放到 synchronized 中

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

        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
                synchronized (locker) {
                    System.out.println("t2 notify 之前");
                    locker.notify();
                    System.out.println("t2 notify 之后");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

在上述代码中：

t1 执行起来后就会立即尝试获取锁，拿到锁后，就立即打印 "t1 进入等待之前"，并进入 wait 方法（释放锁且阻塞等待）

t2 执行起来后，会先 sleep(1000)（保证 t1 能够先拿到锁）

t2 sleep 之后，t1 处于 WAINTING 状态，且锁是释放了的，此时，t2 就会立即拿到锁

t2 打印 "t2 notify 之前"，执行 notify，唤醒 t1（此时 t1 就从 WAITING 状态恢复回来）

但是由于 t2 还未释放锁，t1 WAITING 状态恢复后，会尝试获取锁，此时会处于阻塞 BLOCKED 状态（由于锁竞争引起的）

t2 执行完 "t2 notify 之后"，就会释放锁，且 t2 执行完毕

此时 t1 的wait 就能够获取到锁，并继续执行，打印 "t1 结束等待"

由于，我们也可以知道：当前线程在执行 notify() 方法后，并不会立刻释放锁，而是等 synchronized 代码块执行完后，才会释放锁

如果有多个线程等待，则由线程调度器随机挑选一个处于 wait 状态的线程

notifyAll() 方法

notify() 方法只能唤醒其中一个等待的线程，而使用 notifyAll() 方法可以一次唤醒所有等待线程

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


        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(1000);
                synchronized (locker) {
                    System.out.println("t2 notify 之前");
                    locker.notifyAll();
                    System.out.println("t2 notify 之后");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> {
            System.out.println("t3 进入等待之前");
            synchronized (locker) {
                // 进入等待
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("t3 结束等待");
        });

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