【并发编程】wait、notify、notifyAll 源码分析

最新推荐文章于 2022-12-11 17:30:33 发布
最新推荐文章于 2022-12-11 17:30:33 发布
阅读量455 收藏
点赞数
分类专栏： JDK源码 文章标签： 等待/通知 生产/消费 wait notify ReentrantLock和Condition
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhl_jxy/article/details/87347946
版权

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-concurrent）

一 等待/通知机制

等待/通知机制是线程间通信的一种方式，首先需要了解wait、notify、notifyAll方法含义。

1、 wait()

wait()方法为Object对象的方法，使线程等待，进入阻塞队列。

2、notify()/notifyAll()

notify()随机通知一个线程唤醒，如果通知线程少于等待线程时，将不能及时唤醒多个线程。

notifyAll() 唤醒所有等待执行线程使其继续运行。

3、对象锁的就绪队列和阻塞队列

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，

阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待cpu调度；

否则，一个线程被wait后，就会进入阻塞队列，等待下次被唤醒。

二 wait/notify

1、非wait/notify实例

在实例分析wait/notify前，先通过另外一种方式进行线程间通信。

实例类:

package com.jpeony.concurrent.waitnotify.no;

import java.util.ArrayList;
import java.util.List;

/**
 * @author yihonglei
 */
public class MyList {
    private List<String> list = new ArrayList<String>();

    public void addUserName(String username) {
        list.add(username);
    }

    public int size() {
        return list.size();
    }
}

创建线程A:

package com.jpeony.concurrent.waitnotify.no;

/**
 * @author yihonglei
 */
public class ThreadA extends Thread {
    private MyList myList;

    public ThreadA(MyList myList) {
        super();
        this.myList = myList;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                // 往集合添加元素
                myList.addUserName("element" + (i + 1));
                System.out.println(Thread.currentThread().getName() + "添加了" + myList.size() + "个元素!");
                Thread.sleep(1000);
            }
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

创建线程B:

package com.jpeony.concurrent.waitnotify.no;

/**
 * @author yihonglei
 */
public class ThreadB extends Thread {
    private MyList myList;

    public ThreadB(MyList myList) {
        super();
        this.myList = myList;
    }

    @Override
    public void run() {
        try {
            while (true) {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "还活着");
                if (myList.size() >= 5) {
                    System.out.println("A线程已经将list添加了5个元素，B线程要退出了");
                    // 异常法退出线程
                    throw new InterruptedException();
                }
            }
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

测试类:

package com.jpeony.concurrent.waitnotify.no;

/**
 * 不使用等待/通知模式，通过sleep和while配合实现线程间的通信;
 * A线程不断添加元素，B线程while循环一直检查共享的list，
 * B线程可以根据list做各种判断和处理，从而实现A线程与B线程之间的通信!
 * 即两个线程通过读写一个共享变量来完成线程通信。
 * <p>
 * 这种处理方式的缺点:
 * (1) B线程一直通过某个条件轮询，浪费cpu资源；
 * (2) B线程轮询时间大小，对轮询条件也有影响，渠道的轮询条件有可能出现"错过精准条件"
 * 比如,如果B线程判断改为myList.size() == 5，则可能出现A线程添加到5的时候，
 * B线程没有轮询到，当B线程执行到myList.size()的时候，可能取到的值为6,
 * 哪么就会出现，B线程错过了与A线程精准对接的条件，导致B线程与A线程错过了通信的机会
 *
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        MyList myList = new MyList();

        ThreadA threadA = new ThreadA(myList);
        threadA.setName("A");
        threadA.start();

        ThreadB threadB = new ThreadB(myList);
        threadB.setName("B");
        threadB.start();
    }
}

运行结果:

 

A和B两个线程共享同一个对象，A的修改对于B可见，B线程通过条件判断退出程序。

使用这种方式处理线程通信，有以下缺点：

1）B线程一直通过某个条件轮询，浪费cpu资源；

2）B线程轮询时间大小，对轮询条件也有影响，渠道的轮询条件有可能出现"错过精准条件"

     比如，如果B线程判断改为myList.size() == 5，则可能出现A线程添加到5的时候，

     B线程没有轮询到，当B线程执行到myList.size()的时候，可能取到的值为6，

     哪么就会出现，B线程错过了与A线程精准对接的条件，导致B线程与A线程错过了通信的机会

     所以，为了解决上面这些问题，采用Object对象的wait，notify方法，通过等待/通知机制完成线程间通信。

2、wait/notify实例

创建用于发起等待的A线程:

package com.jpeony.concurrent.waitnotify.yes;

/**
 * 用于处理等待
 *
 * @author yihonglei
 */
public class ThreadA extends Thread {
    private final Object lock;

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

    @Override
    public void run() {
        try {
            synchronized (lock) {
                System.out.println("wait-ThreadA begin time = " + System.currentTimeMillis());
                lock.wait();
                System.out.println("wait-ThreadA end time = " + System.currentTimeMillis());
            }
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

创建用于发起通知的B线程:

package com.jpeony.concurrent.waitnotify.yes;

/**
 * 用于处理通知
 *
 * @author yihonglei
 */
public class ThreadB extends Thread {
    private final Object lock;

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

    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("notify-ThreadB begin time = " + System.currentTimeMillis());
            lock.notify();
            System.out.println("notify-ThreadB end time = " + System.currentTimeMillis());
        }
    }
}

创建测试类:

package com.jpeony.concurrent.waitnotify.yes;

/**
 * 测试代码
 *
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        try {
            Object lock = new Object();
            ThreadA threadA = new ThreadA(lock);
            threadA.start();

            // 5秒后调用唤醒线程，调用notify方法，唤醒等待线程
            Thread.sleep(5000);

            ThreadB threadB = new ThreadB(lock);
            threadB.start();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

运行结果:

线程A调用了wait方法，线程处于等待状态，5秒后线程B执行调用notify唤醒等待线程，

A继续执行完成。

三 wait/notifyAll

关于唤醒一个线程或唤醒多个线程的实例:

1. 一个用于控制线程等待的服务类

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * @author yihonglei
 */
public class MyService {
    public void serviceMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin wait ThreadName = " + Thread.currentThread().getName()
                        + " begin time = " + System.currentTimeMillis());
                lock.wait();
                System.out.println("end wait ThreadName = " + Thread.currentThread().getName()
                        + " end time = " + System.currentTimeMillis());
            }
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

2. 创建线程A

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * @author yihonglei
 */
public class ThreadA extends Thread {
    private Object lock;

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

    @Override
    public void run() {
        MyService service = new MyService();
        service.serviceMethod(lock);
    }
}

3. 创建线程B

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * @author yihonglei
 */
public class ThreadB extends Thread {
    private Object lock;

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

    @Override
    public void run() {
        MyService service = new MyService();
        service.serviceMethod(lock);
    }
}

4. 创建线程C

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * @author yihonglei
 */
public class ThreadC extends Thread {
    private Object lock;

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

    @Override
    public void run() {
        MyService service = new MyService();
        service.serviceMethod(lock);
    }
}

5. 创建通知线程

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * @author yihonglei
 */
public class NotifyThread extends Thread {
    private Object lock;

    public NotifyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            System.out.println("begin general ThreadName = " + Thread.currentThread().getName()
                    + " begin time = " + System.currentTimeMillis());
            // 随机通知一个线程进行唤醒
            lock.notify();
            // 通知全部线程进行唤醒
            // lock.notifyAll();
            System.out.println("end general ThreadName = " + Thread.currentThread().getName()
                    + " end time = " + System.currentTimeMillis());
        }
    }
}

6. 测试类

package com.jpeony.concurrent.waitnotify.notifyall;

/**
 * wait(): 使线程等待，进入阻塞队列。
 * wait(long): 表示一个线程等待指定时间内是否有线程对锁进行唤醒，如果没有，将自动唤醒。
 * general(): 随机通知一个线程唤醒，如果通知线程少于等待线程时，将不能及时唤醒多个线程。
 * notifyAll(): 唤醒所有线程。
 *
 * @author yihonglei
 */
public class RunTest {
    public static void main(String[] args) {
        try {
            // 创建一个锁对象
            Object lock = new Object();

            ThreadA threadA = new ThreadA(lock);
            threadA.setName("A");
            threadA.start();

            ThreadB threadB = new ThreadB(lock);
            threadB.setName("B");
            threadB.start();

            ThreadC threadC = new ThreadC(lock);
            threadC.setName("C");
            threadC.start();

            // 休眠5秒后调用唤醒线程
            Thread.sleep(5000);

            NotifyThread notifyThread = new NotifyThread(lock);
            notifyThread.setName("NotifyThread");
            notifyThread.start();
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
    }
}

7. 运行结果

从运行结果可以知道，线程A，B，C处于等待，过5秒后执行通知线程，唤醒线程。

但是只是显示了A线程被唤醒，B，C线程一直处于等待状态，控制台运行按钮一直显示红色。

这是因为，通知线程调用notify只是随机唤醒一个线程，其余线程未被唤醒，所以处于等待状态。

解决这个问题的办法就是将NotifyThread中的notify方法改成notifyAll,然后再运行程序，运行结果:

从运行结果可以看出，所有线程均被唤醒。

四 总结

1、wait让线程等待执行。

2、notify只能唤醒一个线程，notifyAll唤醒多个线程。

3、等待/通知模型除了用wait/notify，还可以用ReentrantLock的Condition的await/signal实现。

ReentrantLock和Condition参考：https://blog.csdn.net/yhl_jxy/article/details/87088314

 

街灯下的小草
关注
专栏目录
Java并发编程-wait与notify详解及案例实战
program哲学
06-30 146
详细介绍wait和notify关键字及相关应用案例实战
Java的wait和notify学习三部曲之一：JVM源码分析，保洁阿姨看完都会了
m0_64867152的博客
12-29 258
线程C启动后，由于此时线程B持有锁，那么线程C此时在干啥？ 线程B在notify()的时候做了什么？ 线程B释放锁的时候做了什么？ 源码中最重要的注释信息 在源码中有段注释堪称是整篇文章最重要的说明，请大家始终记住这段信息，处处都用得上： ObjectWaiter对象存在于WaitSet、EntryList、cxq等集合中，或者正在这些集合中移动 原文如下： 请务必记住这三个集合：WaitSet、EntryList、cxq 好了，接下来看源码分析问题吧： 线程A在wait()的时候做了什么..
Wait与notify/notifyAll源码分析
he_321的博客
01-18 1148
要理解看懂下面讲解的Wait和notify/notifyAll实现原理，首先要弄明白synchronized的实现原理。synchronized的实现原理可以查看上篇文章。
wait,notify源码实现分析
风起尘落的博客
11-23 572
1. wait,notify都是锁对象来调用的，一个锁对象会维护两个队列，一个是等待队列（存放调用wait方法的线程）,一个是就绪队列（等待获取锁的线程的对象），等待队列的线程是无法参与锁竞争的，只有调用notify/notifyall 后可以把等待队列的线程移到就绪队列中，然后才能参加锁竞争。 openjdk c++源码分析: 路径：openjdk\hotspot\src\share\vm\runtime\objectMonitor.hpp ObjectMonitor() { _head
Object源码阅读，顺带分析了一波notify和wait
chase_Soul的博客
03-31 408
不忘初心，方得始终 Object源码剖析（顺带分析了notify/wait） package java.lang; public class Object { //所有的类都继承了Object,所有对象，包括数组都实现了这个类的方法 private static native void registerNatives(); static { registe...
Object类wait及notify方法原理实例解析
08-24
主要介绍了Object类wait及notify方法原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
文章目录1 wait、notify、notifyAll简单介绍1.1 使用方法 + 为什么不是Thread类的方法1.2 什么时候加锁、什么时候释放锁？1.3 notify、notifyAll的区别2 两个比较经典的使用案例2.1 案例1 — ABCABC。。。三个线程...
Java 中Object的wait() notify() notifyAll()方法使用
08-30
在Java并发编程中，Object的wait()、notify()和notifyAll()方法是非常重要的概念，这三个方法都是Object类的方法，可以认为任意一个Object都是一种资源（或者资源的一个代表）。在并发编程中，线程安全是非常重要的...
Java线程详解：wait、notify、notifyAll、join
liu_shi_jun的专栏
04-22 1345
线程的概念 线程是进程的子任务，一个进程可以创建多个线程，线程不拥有系统资源，但是线程可以共享进程的资源，而线程自己也有一块独立的小块空间：包括堆栈，程序计数器和局部变量。 线程是CPU调度和分派的基本单位。在同一时刻cpu只能执行一段代码，或者说叫一段顺序执行流，也就是线程。cpu在不同的线程之间来回切换，因为cpu的运行速度非常高，看起来就像这些线程一起执行一样，这就是并发。 线程状态 ...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
3. **并发控制**：Java提供了多种并发控制工具，包括synchronized、wait()、notify()、notifyAll()、ReentrantLock（可重入锁）、Semaphore（信号量）和CountDownLatch（倒计时器）等。这些工具用于协调不同线程的...
消息中间件-Notify的概念和原理
06-10
消息中间件-Notify的概念和原理 消息中间件-Notify的概念和原理 消息中间件-Notify的概念和原理
Notify的使用
拱卒的博客
08-22 609
public class NotifyTest { public synchronized void testWait(){ System.out.println(Thread.currentThread().getName() +" Start-----"); try { wait(); } catch (InterruptedException e) { e.printStackTrace();
Python 中Condition条件变量中的wait()和notify()源码解读
Jc_Jc的博客
03-31 2241
Python 中Condition条件变量中的wait()和 notify()源码解读 注： 1、notify()每次只释放和移除n个上层锁； 2、两个线程之间每次交互都会遗留自己的一个上层锁没有释放，但是一个不会造成阻塞，程序正常运行(自己觉得有遗留，有知道的可以评论告知)； 3、每次释放锁之后程序继续执行，只会在获取锁的时候竞争资源产生阻塞； 4、底层锁和上层锁相互制约，有序执行。 ...
结合JDK源码图文详解 wait 和 notify 的工作原理
热门推荐
Shockang的博客
06-08 3万+
前言 本文隶属于专栏《100个问题搞定Java并发》，该专栏为笔者原创，引用请注明来源，不足和错误之处请在评论区帮忙指出，谢谢！ 本专栏目录结构和参考文献请见100个问题搞定Java并发 正文 为了支持多线程之间的协作，JDK 提供了两个非常重要的接口：线程等待 wait() 方法和通知 notify() 方法。 为什么这两个方法并不是在 Thread 类中的，而是在 Object 类里面？ 一方面意味着任何对象都可以调用这两个方法。 另一方面， 无论是 wait() 方法或者 notify() 方法
认识wait(),notify(),notifyAll()方法
最新发布
weixin_56738054的博客
12-11 798
wait,notify,notifyAll
为什么要使用线程池，牢记并理解
春风化雨
11-22 460
1、减少开销提升效率 减少在创建和销毁线程上所花的时间及系统资源的开销；同时，提高系统响应速度，当有任务到达时，通过复用已存在的线程，无需等待新线程的创建便能立即执行 2、提高线程的可管理性 方便线程并发数的管控；线程若是无限制的创建，可能会导致内存占用过多而产生OOM，并且会造成CPU过度切换（CPU切换线程是有时间成本的（需要保持当前执行线程的现场，并恢复要执行线程的现场））。对线程进行统一的分配、调优和监控，从而也提高相应速度；提供更强大的功能，延时定时线程池。 ...
wait notify原理
搓搓那年时光静好
06-14 523
Owner 线程发现条件不满足，调用 wait 方法，即可进入 WaitSet 变为 WAITING 状态 BLOCKED 和 WAITING 的线程都处于阻塞状态，不占用 CPU 时间片 BLOCKED 线程会在 Owner 线程释放锁时唤醒 WAITING 线程会在 Owner 线程调用 notify 或 notifyAll 时唤醒，但唤醒后并不意味者立刻获得锁，仍需进入 EntryList 重新竞争 参考文章: 死磕重量级锁原理 ...
java 多线程& notifyAll()方法：通知所有线程——73
爱的叹息的专栏
06-26 586
唤醒的顺序是正序、倒序、随机，取决于具体的JVM实现，不是所有的JVM在执行notify()时都是按调用wait()方法的正序进行唤醒的，也不是所有的JVM在执行notifyAll()时都是按调用wait()方法的倒序进行唤醒的，具 体的唤醒顺序依赖于JVM的具体实现。...
java并发编程基础之等待通知机制wait/notify原理分析
tom有cat
05-15 1348
一个线程修改了一个对象的值，而另一个线程感知了变化，然后进行了相应的操作，整个过程开始于一个线程，结束于另一个线程。前者是生产者，后者是消费者，这种模式在功能层面上实现了解耦。 有下面一段代码，大家可以根据执行的结果和注释很清晰的明确这个wait和notify的工作机制，wait等待释放锁。代码如下，不再做具体描述： pac...
Java并发编程：线程通信wait、notify与notifyAll详解
本文主要介绍了Java并发编程中的线程间通信机制，重点讲解了wait、notify和notifyAll三个方法的使用、原理以及它们之间的区别。文章通过实例分析，包括ABC顺序打印问题和生产者消费者问题，帮助读者深入理解这些概念...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值