线程之wait/notify机制

最新推荐文章于 2025-03-04 15:14:31 发布

雪子

最新推荐文章于 2025-03-04 15:14:31 发布

阅读量571

点赞数 1

分类专栏：多线程文章标签： wait notify

本文链接：https://blog.youkuaiyun.com/Kermit_father/article/details/95871261

版权

多线程专栏收录该内容

5 篇文章

订阅专栏

本文介绍了Java线程中的等待/通知机制，通过餐厅服务员与厨师的类比来解释这一概念。wait()方法使得当前线程进入等待状态并释放锁，而notify()方法用于唤醒一个等待的线程，这两个方法都需在同步环境中调用。文章还讨论了notifyAll()方法用于唤醒所有等待的线程，并通过代码示例展示了wait(long)方法如何在指定时间后自动唤醒线程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是等待/通知机制

举个栗子：餐厅里，厨师做好菜之后，通知等待中的服务员就是一个简单的等待通知机制

wait：

wait方法代码的作用是使当前执行代码的线程进入等待，wait方法是Object类的方法，该方法用来将当前线程置入“预执行队列当中”，并且在wait所在的代码行处停止执行，直到接到通知或被终端为止。在wait之前，线程必须获得该对象的对象级别锁，即只有在同步方法或同步块中才能调用wait方法。wait方法执行后，当前线程会立马释放锁。

notify：

notify方法在调用前，也要获得当前线程的对象级别的锁，即方法notify也要在同步方法或同步块中调用。该方法用来通知那些可能等待该对象的对象锁的其他线程，需要说明的是，在执行notify方法后，当前线程不会立马释放该对象锁，呈wait状态的线程不能立马获得该对象锁，需要等到notify所在的同步块执行完才会释放该对象锁。

总结：

wait使线程停止运行，notify使通知停止的线程继续执行。

notify一次只会随机唤醒一个线程

看下面的代码：

public class Service {

    public void testMothod(Object lock){
        try{
            synchronized (lock){
                System.out.println(Thread.currentThread().getName()+ " begin wait at " + System.currentTimeMillis());
                lock.wait();
                System.out.println(Thread.currentThread().getName() + " end wait at " + System.currentTimeMillis());
            }
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {

    private Object lock;

    public ThreadA(Object object){
        this.lock = object;
    }

    @Override
    public void run() {
        super.run();
        Service serivce = new Service();
        serivce.testMothod(lock);
    }
}

public class ThreadB extends Thread {

    private Object lock;

    public ThreadB(Object object){
        this.lock = object;
    }

    @Override
    public void run() {
        super.run();
        Service serivce = new Service();
        serivce.testMothod(lock);
    }

}

public class ThreadC extends Thread {

    private Object lock;

    public ThreadC(Object object){
        this.lock = object;
    }

    @Override
    public void run() {
        super.run();
        Service serivce = new Service();
        serivce.testMothod(lock);
    }

}

public class NotifyOne extends Thread {

    private Object lock;

    public NotifyOne(Object object){
        this.lock = object;
    }

    @Override
    public void run() {
        super.run();
        synchronized (lock){
            lock.notify();
        }
    }
}

public class Test {

    public static void main(String[] args) {

        try{
            Object object = new Object();
            ThreadA threadA = new ThreadA(object);
            ThreadB threadB = new ThreadB(object);
            ThreadC threadC = new ThreadC(object);

            threadA.setName("A");
            threadB.setName("B");
            threadC.setName("C");

            threadA.start();
            threadB.start();
            threadC.start();

            Thread.sleep(1000);
            NotifyOne notifyOne = new NotifyOne(object);
            notifyOne.start();
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行结果：

A begin wait at 1563079593045
B begin wait at 1563079593045
C begin wait at 1563079593045
A end wait at 1563079594044

可以看到 notify方法只唤醒了A线程，那么唤醒所有线程的方法就是notifyAll喽

修改NotifyOne类中的notify方法为notifyAll

public class NotifyOne extends Thread {

    private Object lock;

    public NotifyOne(Object object){
        this.lock = object;
    }

    @Override
    public void run() {
        super.run();
        synchronized (lock){
            lock.notifyAll();
        }
    }
}

运行结果：

A begin wait at 1563079801021
C begin wait at 1563079801022
B begin wait at 1563079801022
B end wait at 1563079802012
C end wait at 1563079802012
A end wait at 1563079802012

Process finished with exit code 0

可以看到，A B C三个线程都被唤醒了

wait（long）方法介绍

该方法是等待参数值的时间内如果没有线程对锁进行唤醒，如果超过这个时间，则自动唤醒。

That's ALL !!!!!!