JAVA中wait()和notify()如何使用详解

更新时间：2025年05月08日 10:28:41 作者：Lizhihao＿

这篇文章主要介绍了JAVA中wait()和notify()如何使用的相关资料,wait和notify必须在同步方法或同步块中使用,并且调用对象必须一致,wait和sleep都可被interrupt唤醒,但wait会释放锁,而sleep不会,需要的朋友可以参考下

前言

大家应该都知道，线程之间是抢占式随机执行的，但是我们并不希望这样。因为这样非常混乱，并不好去预估程序的执行结果。我们甚至希望，线程之间能够配合执行，那么我们就可以使用wait()和notify()来做到。

一、wait()方法

wait有两个方法：

wait()：让当前线程进入等待（阻塞）状态。死等，没有唤醒就会一直阻塞

wait(long timeout) ：指定时间内，让线程进入等待（阻塞）状态。

1.wait()主要做的事

使当前执行代码的线程进行等待。（把线程放到等待队列中）
释放当前的锁
满足条件被notify()唤醒，重新尝试获取这个锁

    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();

        System.out.println("wait 之前");

        /**
         * Object中有wait方法,通过Object对象调用wait方法
         * wait没有参数的版本是默认死等
         * wait带参数的版本是指定超时时间，如果超时了还没有notify就继续执行
         *
         * 使用wait有三个操作：
         * （1）释放锁
         * （2）进入阻塞等待，准备接受通知
         * （3）收到通知之后唤醒，并且重新获取锁
         */

        /**
         * 因为wait会解锁，所以wait必须在synchronized内部
         * 而且synchronized括号内的Object对象，必须和调用wait的是同一对象
         */
        synchronized(object) {
            object.wait();
        }
        System.out.println("wait 之后");

    }

2.wait()的结束条件

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

wait 等待时间超时 (wait ⽅法提供⼀个带有 timeout 参数的版本, 来指定等待时间).
其他线程调⽤该等待线程的 interrupt ⽅法, 导致 wait 抛出 InterruptedException 异常，并清除中断标志位(给程序员自由发挥的空间),并重新尝试获取锁。

    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            //获取当前线程
            Thread current = Thread.currentThread();
            int count = 0;
            //标志位默认为false，为true就是被中断了
            while (!current.isInterrupted()) {
                //如果中断位被清空了，不会执行第二次
                System.out.println("t1线程第一次执行" + count++);
                synchronized (locker) {
                    //因为Thread并没有处理这个异常，所以必须在这里使用try-catch处理一下
                    try {
                        //开始等待
                        //如果被interrupt中断会抛出异常，并清除中断位
                        //并重新尝试获取锁
                        locker.wait();
                    } catch (InterruptedException e) {
                        System.err.println("被interrupt唤醒");
                    }
                }
            }
        });

        t1.start();
        while (true) {
            Thread.sleep(1000);
            t1.interrupt();
        }
    }

3.有参数的wait()

    public static void main(String[] args) {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            long start = System.currentTimeMillis();
            System.out.println("wait之前");
            synchronized (locker) {
                try {
                    locker.wait(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            long end = System.currentTimeMillis();
            System.out.println("wait之后 耗时：" + (end - start));
        });

        t1.start();

    }

结果：

二、notify()

notify⽅法是唤醒等待的线程，主要配合wait()：

notify()：唤醒同一对象调用正在wait()的线程，如果有多个线程正在wait(）就会随机唤醒一个线程

notifyAll()：唤醒所有正在wait()的线程

1.notify()主要做的事

⽅法notify()也要在同步⽅法或同步块中调⽤，该⽅法是⽤来通知那些可能等待该对象的对象锁的其它线程，对其发出通知notify，并使它们重新获取该对象的对象锁。

如果有多个线程等待，则有线程调度器随机挑选出⼀个呈 wait 状态的线程。(并没有 "先来后到")

在notify()⽅法后，当前线程不会⻢上释放该对象锁，要等到执⾏notify()⽅法的线程将程序执⾏完，也就是退出同步代码块之后才会释放对象锁。

    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();


        Thread t1 = new Thread(() -> {
            synchronized (locker) {

                System.out.println("wait之前~");

                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("wait之后！");
            }
        });


        Thread t2 = new Thread(() -> {
            synchronized (locker) {

                System.out.println("notify之前");

                locker.notify();

                //notify之后，并不会马上释放锁结束，至少会
                //把synchronized中的语句执行完
                System.out.println("未解锁之后的notify");
            }
            //看是否会执行到这一条语句
            System.err.println("解锁之后的notify");
        });

        t1.start();
        //防止执行到notify了，t2还没阻塞(wait)
        Thread.sleep(500);
        t2.start();

    }

结果分析：

注意事项：

2.notify() 会唤醒sleep()吗？

    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();

        Thread t1 = new Thread(() -> {
            System.out.println("sleep睡眠");
            try {
                //sleep不需要在synchronized里
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("sleep睡醒了");
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("notify之前");
                locker.notify();
                System.out.println("notify之后");
            }
        });

        t1.start();
        Thread.sleep(1000);
        t2.start();
    }

结果：

3.notifyAll()

唤醒所有正在等待的线程

    public static void main(String[] args) throws InterruptedException {
        Object locker = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("t1线程开始");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.err.println("t1线程结束");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("t2线程开始");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.err.println("t2线程结束");
        });
        Thread t3 = new Thread(() -> {
            System.out.println("t3线程开始");
            synchronized (locker) {
                try {
                    locker.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.err.println("t3线程结束");
        });
        Thread t4 = new Thread(() -> {
            synchronized (locker) {
                System.out.println("notify之前");
                locker.notifyAll();
                System.out.println("notify之后");
            }
        });

        t1.start();
        t2.start();
        t3.start();
        //保证上面的线程都已经执行了wait
        Thread.sleep(1000);
        t4.start();
    }

三、调用 wait\notify\synchronized 使用的对象

注意：wait和notify都必须放在synchronized中，不然会抛出异常：IllegalMonitorStateException

    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();
            }
            System.err.println("t1线程结束");
        });

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

        t1.start();
        t4.start();
    }

并且synchronized括号内部，必须和调用的是同一对象，不然依然会抛异常：

    public static void main(String[] args) {
        Object locker1 = new Object();
        Object locker2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (locker1) {
                System.out.println("t1线程开始");
                try {
                    locker2.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.err.println("t1线程结束");
            }
        });

        Thread t4 = new Thread(() -> {
            synchronized (locker1) {
                try {
                    Thread.sleep(1000);
                    locker2.notify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });

        t1.start();
        t4.start();
    }

四、wait和sleep的比较/区别（面试题）

其实理论上 wait 和 sleep 完全是没有可⽐性的，因为⼀个是⽤于线程之间的通信的，⼀个是让线程阻塞⼀段时间。

相同点：

都会让线程放弃执行一段时间

都可以被interrupt唤醒，并且都会抛出 InterruptedException 异常，并且清空标志位

不同点：

wait是Object的方法，sleep是Thread的静态方法

wait必须在synchronized中，sleep不需要

wait阻塞的时候释放锁，sleep并不会，sleep会抱着锁一起阻塞

wait用于线程间通信（如生产者-消费者模型），sleep用于阻塞线程

总结

到此这篇关于JAVA中wait()和notify()如何使用的文章就介绍到这了,更多相关Java wait()和notify()内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

java实现多人聊天系统
这篇文章主要为大家详细介绍了java实现多人聊天系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-09-09
Mybatis如何传入多个参数的实现代码
这篇文章主要介绍了Mybatis如何传入多个参数的实现代码，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-12-12
ElasticSearch不停机重建索引延伸思考及优化详解
这篇文章主要为大家介绍了ElasticSearch不停机重建索引延伸思考及优化详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-02-02
SpringBoot中注解@ConfigurationProperties与@Value的区别与使用详解
本文主要介绍了SpringBoot中注解@ConfigurationProperties与@Value的区别与使用，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-09-09
Java三级菜单工具类实现方式
这篇文章通过实例代码给大家介绍Java三级菜单工具类实现方式,常用的三个字段,子级id、父级id、其次是数组children,本文结合实例代码给大家介绍的非常详细,需要的朋友参考下吧
2024-05-05
带你了解Java数据结构和算法之无权无向图
这篇文章主要为大家介绍了Java数据结构和算法之无权无向图，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助
2022-01-01
SpringBoot项目运行jar包启动的步骤流程解析
这篇文章主要介绍了SpringBoot项目运行jar包启动的步骤流程，本文分步骤通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友参考下吧
2020-07-07
Spring-AOP 静态普通方法名匹配切面操作
这篇文章主要介绍了Spring-AOP 静态普通方法名匹配切面操作，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2021-07-07
Java结构型设计模式中建造者模式示例详解
建造者模式，是一种对象构建模式它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现的对象。本文将通过示例讲解建造者模式，需要的可以参考一下
2022-09-09
基于Java的guava开源库工具类
guava是谷歌基于java封装好的开源库，这篇文章主要通过介绍几个好用的guava工具类，感兴趣的朋友可以参考下面文章内容
2021-09-09