多线程——wait和notify

最新推荐文章于 2025-09-21 15:41:01 发布

原创最新推荐文章于 2025-09-21 15:41:01 发布 · 755 阅读

30 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

多线程专栏收录该内容

18 篇文章

订阅专栏

wait和notify的引入

试想一个这样的场景，ABC三人去atm取钱，当A进入atm后，就会锁上门，也就是对门加锁，此时BC想要进入atm就要等待A开门，也就是释放锁。但是当A进去后发现，atm里没钱，需要等工作人员往里面补钱，所以他就出来了。但是出来之后，他想要知道有钱了没有，所以又需要再进去。当A出来后，就会和BC一起参与到“门”这个锁的竞争中，但是，在这个竞争中，刚刚释放锁的A是有优势的，也就是大概率A又会重新拿到这个锁。如果一直重复下去，就会导致BC无法正确完成工作，而银行工作人员也无法补充现金，导致这个场景卡死。

用代码表示大致是这样：

public static void main(String[] args) {
        Thread A = new Thread(() ->{
            while(true){
                synchronized (门){
                    if (有钱) {
                        //取钱
                        break;
                    } else {

                    }
                }
            }
        });
        Thread B = new Thread(() ->{
            while(true){
                synchronized (门){
                    if (有钱) {
                        //取钱
                        break;
                    } else {

                    }
                }
            }
        });
        Thread C = new Thread(() ->{
            while(true){
                synchronized (门){
                    if (有钱) {
                        //取钱
                        break;
                    } else {

                    }
                }
            }
        });
    }

那如何让A出来后不再进入，而是收到通知后再进入呢？

这就需要使用到wait和notify了

wait的使用

wait的主要作用就是让线程进入等待状态。

wait是Object类的一个方法，可以选择不传入参数，传入一个参数，传入两个参数

如果不传入参数，那么线程就会无限等待下去，直至被唤醒然后解除等待状态。

如果传入参数，那么线程会在时间结束或者被主动唤醒的情况下解除等待状态。

使用wait时，wait会进行以下操作:

        使当前执⾏代码的线程进⾏等待.(把线程放到等待队列中)
        释放当前的锁
        满⾜⼀定条件时被唤醒,重新尝试获取这个锁.

wait的使用一定要配合synchronized来使用，脱离synchronized的wait会直接抛出异常

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

wait结束的条件：

其他线程使用notify方法

等待超时

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

wait使用案例：

public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t = new Thread(() ->{
            synchronized (lock){
                System.out.println("wait之前");
                try {
                    lock.wait(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait之后");
            }
        });
        t.start();
        Thread.sleep(3000);
        System.out.println("3s过去了");
    }

可以看到，进入wait后五秒触发超时，wait结束，线程解除等待，然后正常执行.

notify的使用

norify的作用时唤醒正在wait的线程，有以下几个注意事项：

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

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

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

示例，让wait提前唤醒:

public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(() ->{
            synchronized (lock){
                System.out.println("wait之前");
                try {
                    lock.wait(5000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("wait之后");
            }
        });
        Thread t2 = new Thread(()->{
            synchronized (lock){
                lock.notify();
            }
        });
        t1.start();
        t2.start();
        Thread.sleep(3000);
        System.out.println("3s过去了");
    }

可以看到，由于notify提前唤醒了wait，所以再输出“wait之前”后输出的时“wait之后”再等待3s才输出“3s过去了”.

notifyAll

notifyAll的用法基本一致，唯一的区别是：notifyAll会将所有等待的线程一齐唤醒，让他们重新进入锁的竞争。

解决刚开始的问题

有了这两个方法，就可以完美的解决这个问题，只需要在A观察到没有钱后，让他进入wait中，等待工作人员的notiy即可,代码可以这样表示：

public static void main(String[] args) {
        Object men = new Object();
        Thread A = new Thread(() ->{
            while(true){
                synchronized (men){
                    if (有钱) {
                        //取钱
                        break;
                    } else {
                        try {
                            men.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        Thread B = new Thread(() ->{
            while(true){
                synchronized (men){
                    if (有钱) {
                        //取钱
                        break;
                    } else {
                        try {
                            men.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        Thread C = new Thread(() ->{
            while(true){
                synchronized (men){
                    if (有钱) {
                        //取钱
                        break;
                    } else {
                        try {
                            men.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });
        Thread worker = new Thread(()->{
            synchronized (men){
                //补钱
                men.notifyAll();//通知所有人已经补钱
            }
        });
    }

在worker唤醒所有人后，ABC会重新来竞争“门”这个锁，三个线程谁会拿到这个锁时随机的。