线程安全——wait()和notify的使用

最新推荐文章于 2025-06-04 23:51:55 发布

晚风的你～

最新推荐文章于 2025-06-04 23:51:55 发布

阅读量1.1k

点赞数 8

CC 4.0 BY-SA版权

文章标签： java java-ee spring boot

本文链接：https://blog.youkuaiyun.com/gug12345sheh/article/details/145169849

一、wait()方法

wait()方法是java线程中比较常见的方法，一般配合notify使用，下面详细了解；

1、wait()的作用

wait()方法的作用就是为了让当前执行代码的线程进行等待，也就是把线程放到等待队列中。第二个是为了释放当前所持有的对象锁。满足一定条件会被唤醒(利用notify唤醒或者调时间)

2、wait()的工作场景

wait()的工作场景一般是多线程环境中的生产者-消费者模型、线程同步等场景。当一个线程需要等待某个条件满足时，可以调用wait()方法暂停执行，等待条件满足再被唤醒。

3、wait的三种语法

public void wait() throws InterruptedException;
public void wait(long timeout) throws InterruptedException;
public void wait(long timeout, int nanos) throws InterruptedException;

其中没有参数的wait()方法需要notify来进行唤醒，如果有参数就是需要满足时间条件唤醒(一个参数是毫秒参数，俩个参数第一个参数是毫秒参数，第二个参数是纳秒参数)。

但要十分注意的是，wait()的使用必须要放在同步代码块(synchronized块)中调用，不然就会抛出IllegalMonitorStateException异常，因为wait()需要当前持有对象锁。

以下是纯wait()方法使用例子

public static void main(String[] args) throws InterruptedException {
        Object object1=new Object();
        Object object2=new Object();
        Object object3=new Object();
        System.out.println("wait之前");
//        synchronized (object){
//            object.wait();
//            //只要没有人唤醒，就会一直阻塞
//        }
//        System.out.println("wait之后");
        Thread t1=new Thread(()->{
            synchronized(object1){
                try {
                    object1.wait();
                    System.out.println("wait无参数等待");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t2=new Thread(()->{
            while(true){
                System.out.println("wait一个参数待");
                synchronized(object2){
                    try {
                        object2.wait(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        Thread t3=new Thread(()->{
            while(true){
                System.out.println("wait俩个参数待");
                synchronized(object3){
                    try {
                        object3.wait(3000,500);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

执行结果如下：

我们可以发现，线程t1里面的东西因为wait()等待而没被执行到，下面t2、t3线程都被执行到了，而有参数的wait可以通过参数的时间等待执行一次。这就是wait()用法。

二、notify()方法

notify()方法存在的意义就是为了唤醒线程，必须要通过wait()方法一起使用。

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

        Thread t1=new Thread(()->{
            try {
                Thread.sleep(3000);
                System.out.println("wait之前");
                synchronized (locker){
                    locker.wait();
                }
                System.out.println("wait之后");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t2=new Thread(()->{
            Scanner scanner=new Scanner(System.in);
            System.out.println("输入任意内容");
            scanner.next();
            synchronized (locker){
                locker.notify();
            }
        });
        t1.start();
        t2.start();
    }

当我输入任意内容后，线程被唤醒，打印如下：

三、notifyAll()方法

notifyAll()方法是一个唤醒全部线程的方法，对于我们用wait()方法来让线程等待，我们可以用同一个Object类来用wai()方法进行等待，也可以用多个Object()类来进行wait()使用，如果用同一个Object()类使用wait()方法，使用notify只能唤醒其中一个线程，要想全部线程唤醒必须要用notifyAll()方法，如下：

 public static void main(String[] args) {
        Object locker=new Object();
        Thread t1=new Thread(()->{
            System.out.println("t1wait之前");
                try {
                    synchronized (locker) {
                        locker.wait();
                    }
                    System.out.println("t1wait之后");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
        });
        Thread t2=new Thread(()->{
            System.out.println("t2wait之前");
            try {
                synchronized (locker) {
                    locker.wait(3000);//3秒之后自动唤醒
                }
                System.out.println("t2wait之后");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread t3=new Thread(()->{
            Scanner scanner=new Scanner(System.in);
            System.out.println("输入任意内容，唤醒所有线程");
            scanner.next();
            synchronized (locker){
//                locker.notify();唤醒其中一个
                locker.notifyAll();//唤醒全部
            }
        });
        t1.start();
        t2.start();
        t3.start();
    }

打印结果如下：