Java Thread.join()详解-低调大师

Java Thread.join()详解

2018-03-25 600

一、使用方式。

join是Thread类的一个方法，启动线程后直接调用，例如：

[java]view plain copy
Thread t = new AThread(); t.start(); t.join();  

二、为什么要用join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

三、join方法的作用

在JDk的API里对于join()方法是：

join

public final void join() throws InterruptedException Waits for this thread to die. Throws: InterruptedException - if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

四、用实例来理解

写一个简单的例子来看一下join()的用法：

1.AThread 类

BThread类
TestDemo 类
[java] view plain copy
1. class BThread extends Thread {
2. public BThread() {
3. super("[BThread] Thread");
4. };
5. public void run() {
6. String threadName = Thread.currentThread().getName();
7. System.out.println(threadName + " start.");
8. try {
9. for (int i = 0; i < 5; i++) {
10. System.out.println(threadName + " loop at " + i);
11. Thread.sleep(1000);
12. }
13. System.out.println(threadName + " end.");
14. } catch (Exception e) {
15. System.out.println("Exception from " + threadName + ".run");
16. }
17. }
18. }
19. class AThread extends Thread {
20. BThread bt;
21. public AThread(BThread bt) {
22. super("[AThread] Thread");
23. this.bt = bt;
24. }
25. public void run() {
26. String threadName = Thread.currentThread().getName();
27. System.out.println(threadName + " start.");
28. try {
29. bt.join();
30. System.out.println(threadName + " end.");
31. } catch (Exception e) {
32. System.out.println("Exception from " + threadName + ".run");
33. }
34. }
35. }
36. public class TestDemo {
37. public static void main(String[] args) {
38. String threadName = Thread.currentThread().getName();
39. System.out.println(threadName + " start.");
40. BThread bt = new BThread();
41. AThread at = new AThread(bt);
42. try {
43. bt.start();
44. Thread.sleep(2000);
45. at.start();
46. at.join();
47. } catch (Exception e) {
48. System.out.println("Exception from main");
49. }
50. System.out.println(threadName + " end!");
51. }
52. }
打印结果：
```
main start.    //主线程起动，因为调用了at.join()，要等到at结束了，此线程才能向下执行。 
[BThread] Thread start. 
[BThread] Thread loop at 0 
[BThread] Thread loop at 1 
[AThread] Thread start.    //线程at启动，因为调用bt.join()，等到bt结束了才向下执行。 
[BThread] Thread loop at 2 
[BThread] Thread loop at 3 
[BThread] Thread loop at 4 
[BThread] Thread end. 
[AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果 
main end!      //线程AThread结束，此线程在at.join();阻塞处起动，向下继续执行的结果。
```
修改一下代码:
[java] view plain copy
1. public class TestDemo {
2. public static void main(String[] args) {
3. String threadName = Thread.currentThread().getName();
4. System.out.println(threadName + " start.");
5. BThread bt = new BThread();
6. AThread at = new AThread(bt);
7. try {
8. bt.start();
9. Thread.sleep(2000);
10. at.start();
11. //at.join(); //在此处注释掉对join()的调用
12. } catch (Exception e) {
13. System.out.println("Exception from main");
14. }
15. System.out.println(threadName + " end!");
16. }
17. }
打印结果：
```
main start.    // 主线程起动，因为Thread.sleep(2000)，主线程没有马上结束;

[BThread] Thread start.    //线程BThread起动
[BThread] Thread loop at 0
[BThread] Thread loop at 1
main end!   // 在sleep两秒后主线程结束，AThread执行的bt.join();并不会影响到主线程。
[AThread] Thread start.    //线程at起动，因为调用了bt.join()，等到bt结束了，此线程才向下执行。
[BThread] Thread loop at 2
[BThread] Thread loop at 3
[BThread] Thread loop at 4
[BThread] Thread end.    //线程BThread结束了
[AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果
```
五、从源码看join()方法

在AThread的run方法里，执行了bt.join();，进入看一下它的JDK源码：
[java] view plain copy
1. public final void join() throws InterruptedException {
2. join(0L);
3. }
然后进入join(0L)方法：
[java] view plain copy
1. public final synchronized void join(long l)
2. throws InterruptedException
3. {
4. long l1 = System.currentTimeMillis();
5. long l2 = 0L;
6. if(l < 0L)
7. throw new IllegalArgumentException("timeout value is negative");
8. if(l == 0L)
9. for(; isAlive(); wait(0L));
10. else
11. do
12. {
13. if(!isAlive())
14. break;
15. long l3 = l - l2;
16. if(l3 <= 0L)
17. break;
18. wait(l3);
19. l2 = System.currentTimeMillis() - l1;
20. } while(true);
21. }
单纯从代码上看： * 如果线程被生成了，但还未被起动，isAlive()将返回false，调用它的join()方法是没有作用的。将直接继续向下执行。 * 在AThread类中的run方法中，bt.join()是判断bt的active状态，如果bt的isActive()方法返回false，在bt.join(),这一点就不用阻塞了，可以继续向下进行了。从源码里看，wait方法中有参数，也就是不用唤醒谁，只是不再执行wait，向下继续执行而已。 * 在join()方法中，对于isAlive()和wait()方法的作用对象是个比较让人困惑的问题：

isAlive()方法的签名是：public final native boolean isAlive()，也就是说isAlive()是判断当前线程的状态，也就是bt的状态。

wait()方法在jdk文档中的解释如下：

Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

在这里，当前线程指的是at。

一、使用方式。

join是Thread类的一个方法，启动线程后直接调用，例如：

[java]view plain copy
Thread t = new AThread(); t.start(); t.join();  

二、为什么要用join()方法

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。

三、join方法的作用

在JDk的API里对于join()方法是：

join

public final void join() throws InterruptedException Waits for this thread to die. Throws: InterruptedException - if any thread has interrupted the current thread. The interrupted status of the current thread is cleared when this exception is thrown.

即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

四、用实例来理解

写一个简单的例子来看一下join()的用法：

1.AThread 类

BThread类
TestDemo 类
[java] view plain copy
1. class BThread extends Thread {
2. public BThread() {
3. super("[BThread] Thread");
4. };
5. public void run() {
6. String threadName = Thread.currentThread().getName();
7. System.out.println(threadName + " start.");
8. try {
9. for (int i = 0; i < 5; i++) {
10. System.out.println(threadName + " loop at " + i);
11. Thread.sleep(1000);
12. }
13. System.out.println(threadName + " end.");
14. } catch (Exception e) {
15. System.out.println("Exception from " + threadName + ".run");
16. }
17. }
18. }
19. class AThread extends Thread {
20. BThread bt;
21. public AThread(BThread bt) {
22. super("[AThread] Thread");
23. this.bt = bt;
24. }
25. public void run() {
26. String threadName = Thread.currentThread().getName();
27. System.out.println(threadName + " start.");
28. try {
29. bt.join();
30. System.out.println(threadName + " end.");
31. } catch (Exception e) {
32. System.out.println("Exception from " + threadName + ".run");
33. }
34. }
35. }
36. public class TestDemo {
37. public static void main(String[] args) {
38. String threadName = Thread.currentThread().getName();
39. System.out.println(threadName + " start.");
40. BThread bt = new BThread();
41. AThread at = new AThread(bt);
42. try {
43. bt.start();
44. Thread.sleep(2000);
45. at.start();
46. at.join();
47. } catch (Exception e) {
48. System.out.println("Exception from main");
49. }
50. System.out.println(threadName + " end!");
51. }
52. }
打印结果：
```
main start.    //主线程起动，因为调用了at.join()，要等到at结束了，此线程才能向下执行。 
[BThread] Thread start. 
[BThread] Thread loop at 0 
[BThread] Thread loop at 1 
[AThread] Thread start.    //线程at启动，因为调用bt.join()，等到bt结束了才向下执行。 
[BThread] Thread loop at 2 
[BThread] Thread loop at 3 
[BThread] Thread loop at 4 
[BThread] Thread end. 
[AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果 
main end!      //线程AThread结束，此线程在at.join();阻塞处起动，向下继续执行的结果。
```
修改一下代码:
[java] view plain copy
1. public class TestDemo {
2. public static void main(String[] args) {
3. String threadName = Thread.currentThread().getName();
4. System.out.println(threadName + " start.");
5. BThread bt = new BThread();
6. AThread at = new AThread(bt);
7. try {
8. bt.start();
9. Thread.sleep(2000);
10. at.start();
11. //at.join(); //在此处注释掉对join()的调用
12. } catch (Exception e) {
13. System.out.println("Exception from main");
14. }
15. System.out.println(threadName + " end!");
16. }
17. }
打印结果：
```
main start.    // 主线程起动，因为Thread.sleep(2000)，主线程没有马上结束;

[BThread] Thread start.    //线程BThread起动
[BThread] Thread loop at 0
[BThread] Thread loop at 1
main end!   // 在sleep两秒后主线程结束，AThread执行的bt.join();并不会影响到主线程。
[AThread] Thread start.    //线程at起动，因为调用了bt.join()，等到bt结束了，此线程才向下执行。
[BThread] Thread loop at 2
[BThread] Thread loop at 3
[BThread] Thread loop at 4
[BThread] Thread end.    //线程BThread结束了
[AThread] Thread end.    // 线程AThread在bt.join();阻塞处起动，向下继续执行的结果
```
五、从源码看join()方法

在AThread的run方法里，执行了bt.join();，进入看一下它的JDK源码：
[java] view plain copy
1. public final void join() throws InterruptedException {
2. join(0L);
3. }
然后进入join(0L)方法：
[java] view plain copy
1. public final synchronized void join(long l)
2. throws InterruptedException
3. {
4. long l1 = System.currentTimeMillis();
5. long l2 = 0L;
6. if(l < 0L)
7. throw new IllegalArgumentException("timeout value is negative");
8. if(l == 0L)
9. for(; isAlive(); wait(0L));
10. else
11. do
12. {
13. if(!isAlive())
14. break;
15. long l3 = l - l2;
16. if(l3 <= 0L)
17. break;
18. wait(l3);
19. l2 = System.currentTimeMillis() - l1;
20. } while(true);
21. }
单纯从代码上看： * 如果线程被生成了，但还未被起动，isAlive()将返回false，调用它的join()方法是没有作用的。将直接继续向下执行。 * 在AThread类中的run方法中，bt.join()是判断bt的active状态，如果bt的isActive()方法返回false，在bt.join(),这一点就不用阻塞了，可以继续向下进行了。从源码里看，wait方法中有参数，也就是不用唤醒谁，只是不再执行wait，向下继续执行而已。 * 在join()方法中，对于isAlive()和wait()方法的作用对象是个比较让人困惑的问题：

isAlive()方法的签名是：public final native boolean isAlive()，也就是说isAlive()是判断当前线程的状态，也就是bt的状态。

wait()方法在jdk文档中的解释如下：

Causes the current thread to wait until another thread invokes the notify() method or the notifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

在这里，当前线程指的是at。

微信关注我们

原文链接：https://yq.aliyun.com/articles/577760

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

java并发编程笔记--ScheduledThreadPoolExecutor实现

ScheduledThreadPoolExecutor作为ScheduledExecutorService接口的实现，提供了延迟执行任务或者周期性执行任务的能力。通过名称可以看出，ScheduledThreadPoolExecutor基于线程池实现，它通过继承ThreadPoolExecutor实现线程池管理能力的复用，同时扩展了自己的定时任务调度能力。首先来看ScheduledExecutorServicej接口，它继承了ExecutorService接口，作为任务执行器的一种扩展类型，提供了如下方法： schedule方法：用于任务的单次执行，允许指定延迟时间，当时间为0或者负数时，表示立即执行任务； scheduleAtFixedRate方法：以固定的时间间隔执行任务，当任务本身的执行时间超过时间间隔时，会等到任务执行完成后，立即执行下一次任务；同一个任务总是串行执行，不会并发执行； scheduleWithFixedDelay方法：以固定的延迟执行任务，当前任务执行时间与上一次任务执行时间相隔固定的延迟；任务每次执行完成后，会在结束时间上加上固定的延迟作为下一...

2018-03-25

706

什么是正则表达式正则表达式是用于匹配字符串中字符组合的模式。在 JavaScript中，正则表达式也是对象。这些模式被用于RegExp的exec和test方法, 以及String的match、replace、search和split方法。正则表达式存在于大部分的编程语言，就算是在写shell时也会不经意的用到正则。比如大家最喜欢的rm -rf ./*，这里边的*就是正则的通配符，匹配任意字符。在JavaScript也有正则表达式的实现，差不多就长这个样子：/\d/（匹配一个数字）。个人认为正则所用到的地方还是很多的，比如模版字符的替换、解析URL，表单验证等等一系列。如果在Node.js中用处就更为多，比如请求头的解析、文件内容的批量替换以及写爬虫时候一定会遇到的解析HTML标签。正则表达式在JavaScript中的实现 JavaScript中的语法赘述那些特殊字符的作用并没有什么意义，浪费时间。推荐MDN的文档：基础的正则表达式特殊字符关于正则表达式，个人认为以下几个比较重要：贪婪模式与非贪婪模式 P.S.关于贪婪模式和非贪婪模式，发现有些地方会拿这样的例子： 1 /...

2018-03-25

739

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。