Java多线程8：wait()和notify()/notifyAll()

最新推荐文章于 2024-03-05 22:19:37 发布
最新推荐文章于 2024-03-05 22:19:37 发布
阅读量127 收藏
点赞数
分类专栏： java技术 底层 多线程 文章标签： 多线程
java技术 同时被 3 个专栏收录
294 篇文章 3 订阅
订阅专栏
底层
118 篇文章 0 订阅
订阅专栏
多线程
58 篇文章 0 订阅
订阅专栏

轮询

线程本身是操作系统中独立的个体，但是线程与线程之间不是独立的个体，因为它们彼此之间要相互通信和协作。

想像一个场景，A线程做int型变量i的累加操作，B线程等待i到了10000就打印出i，怎么处理？一个办法就是，B线程while(i == 10000)，这样两个线程之间就有了通信，B线程不断通过轮训来检测i == 10000这个条件。

这样可以实现我们的需求，但是也带来了问题：CPU把资源浪费了B线程的轮询操作上，因为while操作并不释放CPU资源，导致了CPU会一直在这个线程中做判断操作。如果可以把这些轮询的时间释放出来，给别的线程用，就好了。

 

wait/notify

在Object对象中有三个方法wait()、notify()、notifyAll()，既然是Object中的方法，那每个对象自然都是有的。如果不接触多线程的话，这两个方法是不太常见的。下面看一下前两个方法：

1、wait()

wait()的作用是使当前执行代码的线程进行等待，将当前线程置入"预执行队列"中，并且wait()所在的代码处停止执行，直到接到通知或被中断。在调用wait()之前，线程必须获得该对象的锁，因此只能在同步方法/同步代码块中调用wait()方法。

2、notify()

notify()的作用是，如果有多个线程等待，那么线程规划器随机挑选出一个wait的线程，对其发出通知notify()，并使它等待获取该对象的对象锁。注意"等待获取该对象的对象锁"，这意味着，即使收到了通知，wait的线程也不会马上获取对象锁，必须等待notify()方法的线程释放锁才可以。和wait()一样，notify()也要在同步方法/同步代码块中调用。

总结起来就是，wait()使线程停止运行，notify()使停止运行的线程继续运行。

 

wait()/notify()使用示例

看一段代码：

复制代码

public class MyThread30_0 extends Thread
{
    private Object lock;
    
    public MyThread30_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("开始------wait time = " + System.currentTimeMillis());
                lock.wait();
                System.out.println("结束------wait time = " + System.currentTimeMillis());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

复制代码

public class MyThread30_1 extends Thread
{
    private Object lock;
    
    public MyThread30_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        synchronized (lock)
        {
            System.out.println("开始------notify time = " + System.currentTimeMillis());
            lock.notify();
            System.out.println("结束------notify time = " + System.currentTimeMillis());
        }
    }
}

复制代码

写个main函数，同样的Thread.sleep(3000)也是为了保证mt0先运行，这样才能看到wait()和notify()的效果：

复制代码

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread30_0 mt0 = new MyThread30_0(lock);
    mt0.start();
    Thread.sleep(3000);
    MyThread30_1 mt1 = new MyThread30_1(lock);
    mt1.start();
}

复制代码

看一下运行结果：

开始------wait time = 1443931599021
开始------notify time = 1443931602024
结束------notify time = 1443931602024
结束------wait time = 1443931602024

第一行和第二行之间的time减一下很明显就是3s，说明wait()之后代码一直暂停，notify()之后代码才开始运行。

wait()方法可以使调用该线程的方法释放共享资源的锁，然后从运行状态退出，进入等待队列，直到再次被唤醒。

notify()方法可以随机唤醒等待队列中等待同一共享资源的一个线程，并使得该线程退出等待状态，进入可运行状态

notifyAll()方法可以使所有正在等待队列中等待同一共享资源的全部线程从等待状态退出，进入可运行状态 

最后，如果wait()方法和notify()/notifyAll()方法不在同步方法/同步代码块中被调用，那么虚拟机会抛出java.lang.IllegalMonitorStateException，注意一下。

 

wait()释放锁以及notify()不释放锁

多线程的学习中，任何地方都要关注"锁"，wait()和notify()也是这样。wait()方法是释放锁的，写一个例子来证明一下：

复制代码

public class ThreadDomain31
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println(Thread.currentThread().getName() + " Begin wait()");
                lock.wait();
                System.out.println(Thread.currentThread().getName() + " End wait");
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

复制代码

public class MyThread31 extends Thread
{
    private Object lock;
    
    public MyThread31(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain31 td = new ThreadDomain31();
        td.testMethod(lock);
    }
}

复制代码

main函数调用一下：

复制代码

public static void main(String[] args)
{
    Object lock = new Object();
    MyThread31 mt0 = new MyThread31(lock);
    MyThread31 mt1 = new MyThread31(lock);
    mt0.start();
    mt1.start();
}

复制代码

看一下运行结果：

Thread-0 Begin wait()
Thread-1 Begin wait()

如果wait()方法不释放锁，那么Thread-1根本不会进入同步代码块打印的，所以，证明完毕。

接下来证明一下notify()方法不释放锁的结论：

复制代码

public class ThreadDomain32
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait(), ThreadName = " + Thread.currentThread().getName());
                lock.wait();
                System.out.println("End wait(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
    
    public void synNotifyMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin notify(), ThreadName = " + Thread.currentThread().getName());
                lock.notify();
                Thread.sleep(5000);
                System.out.println("End notify(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

写两个线程分别调用2个方法：

复制代码

public class MyThread32_0 extends Thread
{
    private Object lock;
    
    public MyThread32_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain32 td = new ThreadDomain32();
        td.testMethod(lock);
    }
}

复制代码

复制代码

public class MyThread32_1 extends Thread
{
    private Object lock;
    
    public MyThread32_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain32 td = new ThreadDomain32();
        td.synNotifyMethod(lock);
    }
}

复制代码

写个main函数调用一下：

复制代码

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread32_0 mt0 = new MyThread32_0(lock);
    mt0.start();
    MyThread32_1 mt1 = new MyThread32_1(lock);
    mt1.start();
    MyThread32_1 mt2 = new MyThread32_1(lock);
    mt2.start();
}

复制代码

看一下运行结果：

Begin wait(), ThreadName = Thread-0
Begin notify(), ThreadName = Thread-1
End notify(), ThreadName = Thread-1
Begin notify(), ThreadName = Thread-2
End notify(), ThreadName = Thread-2
End wait(), ThreadName = Thread-0

如果notify()方法释放锁，那么在Thread-1调用notify()方法后Thread.sleep(5000)必定应该有其他线程可以进入同步代码块了，但是实际上没有，必须等到Thread-1把代码执行完。所以，证明完毕。

 

interrupt()打断wait()

之前有说过，interrupt()方法的作用不是中断线程，而是在线程阻塞的时候给线程一个中断标识，表示该线程中断。wait()就是"阻塞的一种场景"，看一下用interrupt()打断wait()的例子：

复制代码

public class ThreadDomain33
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait()");
                lock.wait();
                System.out.println("End wait()");
            }
        }
        catch (InterruptedException e)
        {
            System.out.println("wait()被interrupt()打断了！");
            e.printStackTrace();
        }
    }
}

复制代码

复制代码

public class MyThread33 extends Thread
{
    private Object lock;
    
    public MyThread33(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain33 td = new ThreadDomain33();
        td.testMethod(lock);
    }
}

复制代码

复制代码

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread33 mt = new MyThread33(lock);
    mt.start();
    Thread.sleep(5000);
    mt.interrupt();
}

复制代码

看一下运行结果：

复制代码

Begin wait()
wait()被interrupt()打断了！
java.lang.InterruptedException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Object.java:485)
    at com.xrq.example.e33.ThreadDomain33.testMethod(ThreadDomain33.java:12)
    at com.xrq.example.e33.MyThread33.run(MyThread33.java:15)

复制代码

 

notifyAll()唤醒所有线程

利用Object对象的notifyAll()方法可以唤醒处于同一监视器下的所有处于wait的线程，举个例子证明一下：

复制代码

public class ThreadDomain34
{
    public void testMethod(Object lock)
    {
        try
        {
            synchronized (lock)
            {
                System.out.println("Begin wait(), ThreadName = " + Thread.currentThread().getName());
                lock.wait();
                System.out.println("End wait(), ThreadName = " + Thread.currentThread().getName());
            }
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

复制代码

写两个线程，一个调用testMethod(Object lock)的线程，一个notifyAll()线程：

复制代码

public class MyThread34_0 extends Thread
{
    private Object lock;
    
    public MyThread34_0(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        ThreadDomain34 td = new ThreadDomain34();
        td.testMethod(lock);
    }
}

复制代码

复制代码

public class MyThread34_1 extends Thread
{
    private Object lock;
    
    public MyThread34_1(Object lock)
    {
        this.lock = lock;
    }
    
    public void run()
    {
        synchronized (lock)
        {
            lock.notifyAll();
        }
    }
}

复制代码

main函数开三个wait线程，用一个notifyAll的线程去唤醒：

复制代码

public static void main(String[] args) throws Exception
{
    Object lock = new Object();
    MyThread34_0 mt0 = new MyThread34_0(lock);
    MyThread34_0 mt1 = new MyThread34_0(lock);
    MyThread34_0 mt2 = new MyThread34_0(lock);
    mt0.start();
    mt1.start();
    mt2.start();
    Thread.sleep(1000);
    MyThread34_1 mt3 = new MyThread34_1(lock);
    mt3.start();
}

复制代码

看一下运行结果：

Begin wait(), ThreadName = Thread-0
Begin wait(), ThreadName = Thread-2
Begin wait(), ThreadName = Thread-1
End wait(), ThreadName = Thread-1
End wait(), ThreadName = Thread-2
End wait(), ThreadName = Thread-0

当然，唤醒的顺序不重要，因为notifyAll()把处于同一资源下wait的线程全部唤醒，至于唤醒的顺序，就和线程启动的顺序一样，是虚拟机随机的。

 

jacljh
关注
专栏目录
wait()/notify()/notifyAll() 的用法
扛麻袋的少年的博客
12-24 1945
多线程笔记(十)：wait()方法： 该方法用来使得当前线程进入等待状态，直到接到通知或者被中断打断为止。 在调用 wait() 方法之前，线程必须要获得该对象的对象级锁；换句话说就是该方法只能在同步方法或者同步块中调用，如果没有持有合适的锁的话，线程将会抛出异常 IllegalArgumentException。调用 wait() 方法之后，当前线程则释放锁。 notify()方...
Java线程详解：wait、notify、notifyAll、join
liu_shi_jun的专栏
04-22 1394
线程的概念 线程是进程的子任务，一个进程可以创建多个线程，线程不拥有系统资源，但是线程可以共享进程的资源，而线程自己也有一块独立的小块空间：包括堆栈，程序计数器和局部变量。 线程是CPU调度和分派的基本单位。在同一时刻cpu只能执行一段代码，或者说叫一段顺序执行流，也就是线程。cpu在不同的线程之间来回切换，因为cpu的运行速度非常高，看起来就像这些线程一起执行一样，这就是并发。 线程状态 ...
Java多线程（六）：wait()，notify()和notifyAll()
weixin_30389003的博客
07-15 207
wait()，notify()和notifyAll()介绍 1.wait() 使当前线程等待，直到另一个线程调用notify(),notifyAll()或者中断，当前线程调用wait()之前必须持有锁，调用wait()之后会释放锁。等到当前线程重新获得锁，恢复执行。 只能在同步方法调用wait()。 2.notify() 唤醒一个正在等待锁的线程，如果有多个线程在等待锁，那么任意唤醒其中一个wai...
Java并发编程系列之八：wait()、notify()和notifyAll()
rhwayfun专栏
04-02 9809
代码一个线程修改一个对象的值，而另一个线程则感知到了变化，然后进行相应的操作，这就是wait()、notify()和notifyAll()方法的本质。具体体现到方法上则是这样的：一个线程A调用了对象obj的wait方法进入到等待状态，而另一个线程调用了对象obj的notify()或者notifyAll()方法，线程A收到通知后从对象obj的wait方法返回，继续执行后面的操作。可以看到以上两个线程通
wait(),notify()和notifyAll()
weixin_44731875的博客
08-05 253
其实wait()方法就是使线程停止运行。 方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法是用来将当前线程置入“预执行队列”中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。 wait()方法只能在同步方法中或同步块中调用。如果调用wait()时，没有持有适当的锁，会抛出异常。 wait()方法执行后，当前线程释放锁，线程与其它线程竞争重新获取锁 notify方法就是使停止的线程继续运行。 1 方法notify()也要在同步方法或同步
Java 同步方式 wait和notify/notifyall
06-24
总结一下，`wait()`, `notify()`, 和 `notifyAll()` 是Java多线程编程中的核心工具，它们与`synchronized`关键字一起，为线程间的协作提供了强大的支持。理解并熟练掌握这些概念，对于编写高效、安全的多线程程序至...
Java线程通信：wait、notify与notifyAll解析
Java的多线程通信机制是通过`wait()`, `notify()`和`notifyAll()`方法实现的，它们是解决多线程同步问题，特别是涉及线程间协作问题的关键工具。理解并正确使用这些方法是编写高效并发代码的基础。
Java多线程中wait、notify、notifyAll使用详解
08-26
Java多线程中wait、notify、notifyAll使用详解 Java中多线程编程中，wait、notify、notifyAll三个方法是非常重要的，它们都是Object对象的方法，用于线程之间的通信。下面我们将详细介绍这三个方法的使用和作用。 ...
Java线程通讯详解：wait、notify与notifyAll
总结起来，Java中的线程通信通过wait(), notify()和notifyAll()实现，而线程的创建和管理则主要依赖于Runnable接口和Thread类。理解这些基础知识对于进行多线程编程至关重要，可以帮助开发者编写出高效、安全的并发...
wait() 与 notify/notifyAll()
bingguang1993的博客
04-22 371
wait() 与 notify/notifyAll() 是Object类的方法 1. wait() 与notify/notifyAll方法必须在同步代码块中使用 在执行以上方法时，要先获得锁。那么怎么获得锁呢？ 使用synchronized关键字获得锁。因此，wait() 与 notify/notifyAll() 经常与synchronized搭配使用， 即在synchronize...
wait()和notify()以及notifyAll()
tmax52HZ的博客
06-03 165
wait()和notify()以及notifyAll() wait() (1)使线程进入休眠状态 (2)只能在同步方法或同步块中调用wait()方法 notify() (1)在同步方法或者同步块中调用 (2)通知那些处于等待的对象锁的线程。如果有多个线程，则任选其中一个处于wait()状态的线程发出通知。 (3)通知之后，处于wait()的线程不能立马获得该对象锁，需要等到程序执行完syn...
二、多线程[wait()和notify()/notifyAll()]
初出小白
12-05 234
一、 wait()和notify()/notifyAll() 锁,这里讲的就是同步锁,同步执行的锁,释放完之后“锁”之后就丧失了执行能力了,直到notify通知到wait方法, (notify并不是释放锁),只是通知wait可以去竞争锁了,wait并不是立刻得到锁,锁在别人手里,等待别人释放。 为什么要用这个 ? 线程本身是操作系统中独立的个体，但是线程与线程之间不是独立的个体，因为它们彼此之...
Java线程之wait()、notify()、notifyAll()
码客
03-24 320
翻译：https://www.journaldev.com/1037/java-thread-wait-notify-and-notifyall-example 简述 java中Objct对象包含三个方法用于线程之间对于资源锁状态进行通讯，这三个方法分别是wait()、notify()、notifyAll()，今天我们就来学习一下这三个方法的应用。 任何对象上调用这些方法的当前线程都应该...
wait()和notifyAll()使用---生产者和消费者模型
weixin_43946462的博客
06-01 248
锁池和等待池 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。 等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中 notify和notifyAll的区别   如果线程调用了对象的 wait(
wait（），notify（），notifyAll（）三个方法（加面试题）
weixin_47111088的博客
06-10 196
* wait();一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。 * notify():一旦执行此方法，就会唤醒被wait（）的一个线程。如果有多个线程被wait，就会唤醒优先级高的哪一个线程。 * notifyAll():一旦执行此方法，机会唤醒所有被wait的线程。 * * 说明： * 1、wait();notify():notifyAll():这三个方法都必须使用同步代码块或同步方法之中。 * 2、wait();notify():notifyAll():这三个方法的调用者必须是同步代码..
wait()、notify()和notifyAll()
如不來的博客
10-09 200
在Object.java中，定义了wait()、notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程——notify()是唤醒单个线程，而notifyAll()是唤醒所有的线程。 Object类中关于等待/唤醒的API详细信息如下...
线程之间的通信—wait()、notify()、notifyAll()
qq_45036591的博客
11-23 988
wait()和notify()是进行线程间通讯的两个重要的方法。 1.wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”，当前线程被唤醒(进入“就绪状态”) 2.notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，...
wait() 、notify()、notifyAll() 的详细用法
最新发布
Shine0115的博客
03-05 1752
首先，我们知道，线程的执行顺序是随机的(操作系统随机调度的，抢占式执行)，但是有时候，我们并不喜欢这种随机的执行，更喜欢的是它们能够顺序的执行，所以，Java就引入了一种机制，wait() 和 notify() ，它们的而前面的文章中也讲过一个方法，也是能影响线程的执行顺序，但是呢，这个join只能控制线程结束的顺序，而我们想要的是，线程不结束，也能按照我们自己规定的顺序去依次执行；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值