线程join_Java 并发编程:线程间的协作(wait/notify/sleep/yield/join)
点击上方“Coder编程”,选择“置顶公众号”
技术文章第一时间送达!
每天进步一点,不做curd工程师与Api调用工程师 欢迎访问
个人博客网站:https://www.coder-programming.cn/
作者:liuxiaopeng | http://www.cnblogs.com/paddix
一、线程的状态
Java中线程中状态可分为五种:New(新建状态),Runnable(就绪状态),Running(运行状态),Blocked(阻塞状态),Dead(死亡状态)。
New:新建状态,当线程创建完成时为新建状态,即new Thread(...),还没有调用start方法时,线程处于新建状态。
Runnable:就绪状态,当调用线程的的start方法后,线程进入就绪状态,等待CPU资源。处于就绪状态的线程由Java运行时系统的线程调度程序(thread scheduler)来调度。
Running:运行状态,就绪状态的线程获取到CPU执行权以后进入运行状态,开始执行run方法。
Blocked:阻塞状态,线程没有执行完,由于某种原因(如,I/O操作等)让出CPU执行权,自身进入阻塞状态。
Dead:死亡状态,线程执行完成或者执行过程中出现异常,线程就会进入死亡状态。
这五种状态之间的转换关系如下图所示:
有了对这五种状态的基本了解,现在我们来看看Java中是如何实现这几种状态的转换的。
二、wait/notify/notifyAll方法的使用
1、wait方法:
JDK中一共提供了这三个版本的方法,
(1)wait()方法的作用是将当前运行的线程挂起(即让其进入阻塞状态),直到notify或notifyAll方法来唤醒线程.
(2)wait(long timeout),该方法与wait()方法类似,唯一的区别就是在指定时间内,如果没有notify或notifAll方法的唤醒,也会自动唤醒。
(3)至于wait(long timeout,long nanos),本意在于更精确的控制调度时间,不过从目前版本来看,该方法貌似没有完整的实现该功能,其源码(JDK1.8)如下:
public final void wait(long timeout, int nanos) throws InterruptedException { if (timeout 0) { throw new IllegalArgumentException("timeout value is negative"); }
if (nanos 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); }
if (nanos >= 500000 || (nanos != 0 && timeout == 0)) { timeout++; }
wait(timeout); }
从源码来看,JDK8中对纳秒的处理,只做了四舍五入,所以还是按照毫秒来处理的,可能在未来的某个时间点会用到纳秒级别的精度。虽然JDK提供了这三个版本,其实最后都是调用`wait(long timeout)`方法来实现的,wait()方法与wait(0)等效,而`wait(long timeout,int nanos)`从上面的源码可以看到也是通过`wait(long timeout)`来完成的。下面我们通过一个简单的例子来演示wait()方法的使用:
package com.paddx.test.concurrent;
public class WaitTest {
public void testWait(){ System.out.println("Start-----"); try { wait(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("End-------"); }
public static void main(String[] args) { final WaitTest test = new WaitTest(); new Thread(new Runnable() { @Override public void run() { test.testWait(); } }).start(); }}
这段代码的意图很简单,就是程序执行以后,让其暂停一秒,然后再执行。运行上述代码,查看结果:
Start-----Exception in thread "Thread-0" java.lang.IllegalMonitorStateException at java.lang.Object.wait(Native Method) at com.paddx.test.concurrent.WaitTest.testWait(WaitTest.java:8) at com.paddx.test.concurrent.WaitTest$1.run(WaitTest.java:20) at java.lang.Thread.run(Thread.java:745)
这段程序并没有按我们的预期输出相应结果,而是抛出了一个异常。大家可能会觉得奇怪为什么会抛出异常?而抛出的IllegalMonitorStateException
异常又是什么?我们可以看一下JDK中对IllegalMonitorStateException
的描述:
Thrown to indicate that a thread has attempted to wait on an object's monitor or to notify other threads waiting on an object's monitor without owning the specified monitor.
这句话的意思大概就是:线程试图等待对象的监视器或者试图通知其他正在等待对象监视器的线程,但本身没有对应的监视器的所有权。其实这个问题在《Java并发编程:Synchronized及其实现原理》一文中有提到过,wait方法是一个本地方法,其底层是通过一个叫做监视器锁的对象来完成的。所以上面之所以会抛出异常,是因为在调用wait方式时没有获取到monitor对象的所有权,那如何获取monitor对象所有权?Java中只能通过Synchronized关键字来完成,修改上述代码,增加Synchronized关键字:
package com.paddx.test.concurrent;
public class WaitTest {
public synchronized void testWait(){//增加Synchronized关键字 System.out.println("Start-----"); try { wait(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("End-------"); }
public static void main(String[] args) { final WaitTest test = new WaitTest(); new Thread(new Runnable() { @Override public void run() { test.testWait(); } }).start(); }}
现在再运行上述代码,就能看到预期的效果了:
Start-----End-------
所以,通过这个例子,大家应该很清楚,wait方法的使用必须在同步的范围内,否则就会抛出IllegalMonitorStateException
异常,wait
方法的作用就是阻塞当前线程等待notify/notifyAll
方法的唤醒,或等待超时后自动唤醒。
2、notify/notifyAll方法
有了对wait方法原理的理解,notify方法和notifyAll方法就很容易理解了。既然wait方式是通过对象的monitor对象来实现的,所以只要在同一对象上去调用notify/notifyAll方法,就可以唤醒对应对象monitor上等待的线程了。notify和notifyAll的区别在于前者只能唤醒monitor上的一个线程,对其他线程没有影响,而notifyAll则唤醒所有的线程,看下面的例子很容易理解这两者的差别:
package com.paddx.test.concurrent;
public class NotifyTest { public synchronized void testWait(){ System.out.println(Thread.currentThread().getName() +" Start-----"); try { wait(0); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() +" End-------"); }
public static void main(String[] args) throws InterruptedException { final NotifyTest test = new NotifyTest(); for(int i=0;i<5;i++) { new Thread(new Runnable() { @Override public void run() { test.testWait(); } }).start(); }
synchronized (test) { test.notify(); } Thread.sleep(3000); System.out.println("-----------分割线-------------");
synchronized (test) { test.notifyAll(); } }}
输出结果如下:
Thread-0 Start-----Thread-1 Start-----Thread-2 Start-----Thread-3 Start-----Thread-4 Start-----Thread-0 End------------------分割线-------------Thread-4 End-------Thread-3 End-------Thread-2 End-------Thread-1 End-------
从结果可以看出:调用notify
方法时只有线程Thread-0
被唤醒,但是调用notifyAll
时,所有的线程都被唤醒了。
最后,有两点点需要注意:
(1)调用wait方法后,线程是会释放对monitor对象的所有权的。
(2)一个通过wait方法阻塞的线程,必须同时满足以下两个条件才能被真正执行:
- 线程需要被唤醒(超时唤醒或调用notify/notifyll)。
- 线程唤醒后需要竞争到锁(monitor)。
三、sleep/yield/join方法解析
上面我们已经清楚了wait和notify方法的使用和原理,现在我们再来看另外一组线程间协作的方法。这组方法跟上面方法的最明显区别是:这几个方法都位于Thread类中,而上面三个方法都位于Object类中。至于为什么,大家可以先思考一下。现在我们逐个分析sleep/yield/join方法:
1、sleep
sleep方法的作用是让当前线程暂停指定的时间(毫秒),sleep方法是最简单的方法,在上述的例子中也用到过,比较容易理解。唯一需要注意的是其与wait方法的区别。最简单的区别是,wait方法依赖于同步,而sleep方法可以直接调用。而更深层次的区别在于sleep方法只是暂时让出CPU的执行权,并不释放锁。而wait方法则需要释放锁。
package com.paddx.test.concurrent;
public class SleepTest { public synchronized void sleepMethod(){ System.out.println("Sleep start-----"); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Sleep end-----"); }
public synchronized void waitMethod(){ System.out.println("Wait start-----"); synchronized (this){ try { wait(1000); } catch (InterruptedException e) { e.printStackTrace(); } } System.out.println("Wait end-----"); }
public static void main(String[] args) { final SleepTest test1 = new SleepTest();
for(int i = 0;i<3;i++){ new Thread(new Runnable() { @Override public void run() { test1.sleepMethod(); } }).start(); }
try { Thread.sleep(10000);//暂停十秒,等上面程序执行完成 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("-----分割线-----");
final SleepTest test2 = new SleepTest();
for(int i = 0;i<3;i++){ new Thread(new Runnable() { @Override public void run() { test2.waitMethod(); } }).start(); }
}}
执行结果:
Sleep start-----Sleep end-----Sleep start-----Sleep end-----Sleep start-----Sleep end----------分割线-----Wait start-----Wait start-----Wait start-----Wait end-----Wait end-----Wait end-----
这个结果的区别很明显,通过sleep方法实现的暂停,程序是顺序进入同步块的,只有当上一个线程执行完成的时候,下一个线程才能进入同步方法,sleep暂停期间一直持有monitor对象锁,其他线程是不能进入的。而wait方法则不同,当调用wait方法后,当前线程会释放持有的monitor对象锁,因此,其他线程还可以进入到同步方法,线程被唤醒后,需要竞争锁,获取到锁之后再继续执行。
2、yield方法 yield方法的作用是暂停当前线程,以便其他线程有机会执行,不过不能指定暂停的时间,并且也不能保证当前线程马上停止。yield方法只是将Running状态转变为Runnable状态。我们还是通过一个例子来演示其使用:
package com.paddx.test.concurrent;
public class YieldTest implements Runnable { @Override public void run() { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } for(int i=0;i<5;i++){ System.out.println(Thread.currentThread().getName() + ": " + i); Thread.yield(); } }
public static void main(String[] args) { YieldTest runn = new YieldTest(); Thread t1 = new Thread(runn,"FirstThread"); Thread t2 = new Thread(runn,"SecondThread");
t1.start(); t2.start();
}}
运行结果如下:
FirstThread: 0SecondThread: 0FirstThread: 1SecondThread: 1FirstThread: 2SecondThread: 2FirstThread: 3SecondThread: 3FirstThread: 4SecondThread: 4
这个例子就是通过yield方法来实现两个线程的交替执行。不过请注意:这种交替并不一定能得到保证,源码中也对这个问题进行说明:
/** * A hint to the scheduler that the current thread is willing to yield * its current use of a processor. The scheduler is free to ignore this * hint. * *
Yield is a heuristic attempt to improve relative progression
* between threads that would otherwise over-utilise a CPU. Its use
* should be combined with detailed profiling and benchmarking to
* ensure that it actually has the desired effect.
*
*
It is rarely appropriate to use this method. It may be useful
* for debugging or testing purposes, where it may help to reproduce
* bugs due to race conditions. It may also be useful when designing
* concurrency control constructs such as the ones in the
* {@link java.util.concurrent.locks} package.
*/
这段话主要说明了三个问题:
- 调度器可能会忽略该方法。
- 使用的时候要仔细分析和测试,确保能达到预期的效果。
- 很少有场景要用到该方法,主要使用的地方是调试和测试。
3、join方法
join方法的作用是父线程等待子线程执行完成后再执行,换句话说就是将异步执行的线程合并为同步的线程。JDK中提供三个版本的join方法,其实现与wait方法类似,join()方法实际上执行的join(0),而join(long millis, int nanos)也与wait(long millis, int nanos)的实现方式一致,暂时对纳秒的支持也是不完整的。我们可以看下join方法的源码,这样更容易理解:
public final void join() throws InterruptedException { join(0); }
public final synchronized void join(long millis)throws InterruptedException { long base = System.currentTimeMillis(); long now = 0;
if (millis 0) { throw new IllegalArgumentException("timeout value is negative"); }
if (millis == 0) { while (isAlive()) { wait(0); } } else { while (isAlive()) { long delay = millis - now; if (delay <= 0) { break; } wait(delay); now = System.currentTimeMillis() - base; } } }
public final synchronized void join(long millis, int nanos)throws InterruptedException {
if (millis 0) { throw new IllegalArgumentException("timeout value is negative"); }
if (nanos 0 || nanos > 999999) { throw new IllegalArgumentException( "nanosecond timeout value out of range"); }
if (nanos >= 500000 || (nanos != 0 && millis == 0)) { millis++; }
join(millis); }
大家重点关注一下join(long millis)方法的实现,可以看出join方法就是通过wait方法来将线程的阻塞,如果join的线程还在执行,则将当前线程阻塞起来,直到join的线程执行完成,当前线程才能执行。不过有一点需要注意,这里的join只调用了wait方法,却没有对应的notify方法,原因是Thread的start方法中做了相应的处理,所以当join的线程执行完成以后,会自动唤醒主线程继续往下执行。下面我们通过一个例子来演示join方法的作用:
(1)不使用join方法:
package com.paddx.test.concurrent;
public class JoinTest implements Runnable{ @Override public void run() {
try { System.out.println(Thread.currentThread().getName() + " start-----"); Thread.sleep(1000); System.out.println(Thread.currentThread().getName() + " end------"); } catch (InterruptedException e) { e.printStackTrace(); } }
public static void main(String[] args) { for (int i=0;i<5;i++) { Thread test = new Thread(new JoinTest()); test.start(); }
System.out.println("Finished~~~"); }}
执行结果如下:
Thread-0 start-----Thread-1 start-----Thread-2 start-----Thread-3 start-----Finished~~~Thread-4 start-----Thread-2 end------Thread-4 end------Thread-1 end------Thread-0 end------Thread-3 end------
(2)使用join方法:
package com.paddx.test.concurrent;
public class JoinTest implements Runnable{ @Override public void run() {
try { System.out.println(Thread.currentThread().getName() + " start-----"); Thread.sleep(1000); System.out.println(Thread.currentThread().getName() + " end------"); } catch (InterruptedException e) { e.printStackTrace(); } }
public static void main(String[] args) { for (int i=0;i<5;i++) { Thread test = new Thread(new JoinTest()); test.start(); try { test.join(); //调用join方法 } catch (InterruptedException e) { e.printStackTrace(); } }
System.out.println("Finished~~~"); }}
执行结果如下:
Thread-0 start-----Thread-0 end------Thread-1 start-----Thread-1 end------Thread-2 start-----Thread-2 end------Thread-3 start-----Thread-3 end------Thread-4 start-----Thread-4 end------Finished~~~
对比两段代码的执行结果很容易发现,在没有使用join方法之间,线程是并发执行的,而使用join方法后,所有线程是顺序执行的。
四、总结
本文主要详细讲解了wait/notify/notifyAll和sleep/yield/join
方法。最后回答一下上面提出的问题:wait/notify/notifyAll方法的作用是实现线程间的协作,那为什么这三个方法不是位于Thread类中,而是位于Object类中?位于Object中,也就相当于所有类都包含这三个方法(因为Java中所有的类都继承自Object类)。要回答这个问题,还是得回过来看wait方法的实现原理,大家需要明白的是,wait等待的到底是什么东西?如果对上面内容理解的比较好的话,我相信大家应该很容易知道wait等待其实是对象monitor,由于Java中的每一个对象都有一个内置的monitor对象,自然所有的类都理应有wait/notify方法。
相关文章
Java 并发编程:核心理论
Java并发编程:Synchronized及其实现原理
Java并发编程:Synchronized底层优化(轻量级锁、偏向锁)
文末
文章收录至 Github: https://github.com/CoderMerlin/coder-programmingGitee: https://gitee.com/573059382/coder-programming欢迎关注并star~
我知道你 “在看”
线程join_Java 并发编程:线程间的协作(wait/notify/sleep/yield/join)相关推荐
- 高并发编程-线程通信_使用wait和notify进行线程间的通信2_多生产者多消费者导致程序假死原因分析
文章目录 概述 jstack或者可视化工具检测是否死锁(没有) 原因分析 概述 高并发编程-线程通信_使用wait和notify进行线程间的通信 - 遗留问题 我们看到了 应用卡住了 .... 怀疑是 ...
- 并发编程——线程协作
并发编程--线程协作 前面学习了线程,那么并发编程中,如何协调多个线程来开发呢? Semaphore 信号量跟前面将的同步互斥解决方案--信号量是一个东西,这是JDK的信号量实现. 源码分析 ...
- python 线程同步_Python并发编程-线程同步(线程安全)
Python并发编程-线程同步(线程安全) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 线程同步,线程间协调,通过某种技术,让一个线程访问某些数据时,其它线程不能访问这些数据,直 ...
- 判断线程是否执行完毕_Java并发编程 | 线程核心机制,基础概念扩展
源码地址:GitHub || GitEE 一.线程基本机制 1.概念描述 并发编程的特点是:可以将程序划分为多个分离且独立运行的任务,通过线程来驱动这些独立的任务执行,从而提升整体的效率.下面提供一个 ...
- 最新天猫面试题(含总结):线程池+并发编程+分布式设计+中间件
最新天猫面试题(含总结):线程池+并发编程+分布式设计+中间件 https://my.oschina.net/u/3892...
- auto.js停止所有线程_Java线程与并发编程实践:深入理解volatile和final变量
同步有两种属性:互斥性和可见性.synchronized关键字与两者都有关系.Java同时也提供了一种更弱的.仅仅包含可见性的同步形式,并且只以volatile关键字关联. 假设你自己设计了一个停止线 ...
- 《Java线程与并发编程实践》—— 2.3 谨防活跃性问题
本节书摘来异步社区<Java线程与并发编程实践>一书中的第2章,第2.3节,作者: [美]Jeff Friesen,更多章节内容可以访问云栖社区"异步社区"公众号查看. ...
- 《Java线程与并发编程实践》—— 2.6 小结
本节书摘来异步社区<Java线程与并发编程实践>一书中的第2章,第2.6节,作者: [美]Jeff Friesen,更多章节内容可以访问云栖社区"异步社区"公众号查看. ...
- 《Java线程与并发编程实践》—— 1.2 操作更高级的线程任务
本节书摘来异步社区<Java线程与并发编程实践>一书中的第1章,第1.2节,作者: [美]Jeff Friesen,更多章节内容可以访问云栖社区"异步社区"公众号查看. ...
最新文章
- Git详解之九 Git内部原理
- ZJU-java进阶笔记 第七周(输入输出)
- Wiz开发 定时器的使用与处理
- python结果输出到excel-python实现数据导出到excel的示例--普通格式
- 自定义控件(一) Activity的构成(PhoneWindow、DecorView)
- Java 为什么不支持创建泛型化数组
- sql 除以_使用SQL分析游戏运营情况
- chrome开启touch屏幕点击事件
- 数字非压缩光端机的选购原则
- Python3 爬虫学习笔记 C01 【基本库 urllib 的使用】
- 经典面试题(16):以下代码将输出的结果是什么?
- 电气研究生做计算机视觉,UCI研究生电气工程专业排名!师哥带你瞬间拿下
- (35)Verilog HDL算术运算:取模、指数、对数
- 方法区jdk1.7,1.8版本的构造变化
- 如何高级地对抗恶意程序的糖衣炮弹?
- C#获取字符串中某个字符出现的次数
- Python最吃香的5个就业方向,薪资收入也非常可观!
- 计算机专业助我成长作文600,梦想助我成长作文600字
- YOLOv5、CNN、SVM实现车牌检测
- matlab 矩阵与向量乘法,性能:Matlab与C矩阵向量乘法
热门文章
- org.xml.sax.SAXParseException; lineNumber: 11; columnNumber: 110; schema_reference.4: 无法读取方案文档
- Centos出现-bash: unzip: command not found的解决办法
- React简介及基础用法
- android 端口进程号,Android中如何根据端口号寻找对应的进程
- PageHelper分页时超过最大数量的页数仍然返回数据,PageHelper分页失效
- l3asnumanode 设置_linux numa 配置
- c语言传递多个参数给线程,关于ssl多线程参数的传递
- 折线图x轴的日期会超出_matplotlib之折线图(代码+解析)
- jq之$(“tr:even“).css(“background-color“,“yellow“)
- 当前完整路径_详解关键路径法,这可能是你找得到最详细的了