Thread.join()方法解析

最新推荐文章于 2025-06-14 12:03:32 发布
原创 最新推荐文章于 2025-06-14 12:03:32 发布 · 1.6w 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jdk #thread #线程 #join

本文深入解析Java中的Thread.join()方法，包括其原理、用法及常见应用场景。通过具体代码示例，展示如何利用Thread.join()确保主线程在子线程执行完毕后再继续执行，以及如何设置超时等待时间来优化程序性能。
部署运行你感兴趣的模型镜像

API：

join

public final void join()
                throws InterruptedException
等待该线程终止。


抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的 中断状态 被清除。

join

public final void join(long millis)
                throws InterruptedException
等待该线程终止的时间最长为 millis 毫秒。超时为 0 意味着要一直等下去。


参数：
millis - 以毫秒为单位的等待时间。
抛出：
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的 中断状态 被清除。

join

public final void join(long millis,
                       int nanos)
                throws InterruptedException
等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。


参数：
millis - 以毫秒为单位的等待时间。
nanos - 要等待的 0-999999 附加纳秒。
抛出：
IllegalArgumentException - 如果 millis 值为负，则 nanos 的值不在 0-999999 范围内。
InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的 中断状态 被清除。

解析：

Thread.join()，是用来指定当前主线程等待其他线程执行完毕后，再来继续执行Thread.join()后面的代码。


例1：

package com.example;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DataSourcesLoader implements Runnable{

	@Override
	public void run() {
		System.out.printf("Beginning data sources loading: %s\n",new Date());
	    try {
	      TimeUnit.SECONDS.sleep(4);
	    } catch (InterruptedException e) {
	      e.printStackTrace();
	    }
	    System.out.printf("Data sources loading has finished: %s\n",new Date());
	}

	public static void main(String[] args){
		DataSourcesLoader dsLoader = new DataSourcesLoader();
	    Thread thread1 = new Thread(dsLoader,"DataSourceThread");
	    
	    thread1.start();
	    
	    try {
	        thread1.join();
	      } catch (InterruptedException e) {
	        e.printStackTrace();
	      }
	      
	      System.out.printf("Main: Configuration has been loaded: %s\n",new Date());
	}

}
执行结果： 

Beginning data sources loading: Fri Nov 14 14:27:31 CST 2014
Data sources loading has finished: Fri Nov 14 14:27:35 CST 2014
Main: Configuration has been loaded: Fri Nov 14 14:27:35 CST 2014
如果去掉thread1.join()，执行的结果如下： 

Main: Configuration has been loaded: Fri Nov 14 14:28:33 CST 2014
Beginning data sources loading: Fri Nov 14 14:28:33 CST 2014
Data sources loading has finished: Fri Nov 14 14:28:37 CST 2014
通过结果，就可以很明显的说明上面红字的部分：“ 再来继续执行Thread.join()后面的代码”

例2：

package com.example;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DataSourcesLoader implements Runnable{

	@Override
	public void run() {
		System.out.printf("Beginning data sources loading: %s\n",new Date());
	    try {
	      TimeUnit.SECONDS.sleep(4);
	    } catch (InterruptedException e) {
	      e.printStackTrace();
	    }
	    System.out.printf("Data sources loading has finished: %s\n",new Date());
	}

	public static void main(String[] args){
		DataSourcesLoader dsLoader = new DataSourcesLoader();
	    Thread thread1 = new Thread(dsLoader,"DataSourceThread");
	    
	    thread1.start();
	    
	    try {
	        thread1.join(3000);
	      } catch (InterruptedException e) {
	        e.printStackTrace();
	      }
	      
	      System.out.printf("Main: Configuration has been loaded: %s\n",new Date());
	}

}

这里使用的是： 
thread1.join(3000);
这句话的意思是，只要满足下面2个条件中的一个时，主线程就会继续执行thread.join()后面的代码：

条件1：thread1 执行完毕；

条件2：已经等待 thread1 执行了3000ms.

例子中，thread1 自身的执行时间是4s，而设置的等待时间是3s，所以得到的执行结果如下，thread1还没有执行完，主线程就开始执行后面的代码，因为 thread1 等待的时间已经超时了：

Beginning data sources loading: Fri Nov 14 14:35:45 CST 2014
Main: Configuration has been loaded: Fri Nov 14 14:35:48 CST 2014
Data sources loading has finished: Fri Nov 14 14:35:49 CST 2014



那么结合上面的2个例子，我们可以推断出下面代码的执行结果了：

例3：

package com.example;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class DataSourcesLoader implements Runnable{

	@Override
	public void run() {
		System.out.printf("Beginning data sources loading: %s\n",new Date());
	    try {
	      TimeUnit.SECONDS.sleep(4);
	    } catch (InterruptedException e) {
	      e.printStackTrace();
	    }
	    System.out.printf("Data sources loading has finished: %s\n",new Date());
	}

}

package com.example;

import java.util.Date;
import java.util.concurrent.TimeUnit;

public class NetworkConnectionsLoader implements Runnable{

	@Override
	public void run() {
		System.out.printf("Beginning network connect loading: %s\n",new Date());
	    try {
	      TimeUnit.SECONDS.sleep(6);
	    } catch (InterruptedException e) {
	      e.printStackTrace();
	    }
	    System.out.printf("Network connect loading has finished: %s\n",new Date());
		
	}
	
	public static void main(String[] args){
		DataSourcesLoader dsLoader = new DataSourcesLoader();
	    Thread thread1 = new Thread(dsLoader,"DataSourceThread");
	    
	    NetworkConnectionsLoader ncLoader = new NetworkConnectionsLoader();
	    Thread thread2 = new Thread(ncLoader,"NetworkConnectionLoader");
	    
	    thread1.start();
	    thread2.start(); 
	    
	    try {
	        thread1.join();
	        thread2.join(1900);
	      } catch (InterruptedException e) {
	        e.printStackTrace();
	      }
	      
	      System.out.printf("Main: Configuration has been loaded: %s\n",new Date());
	}

}
执行结果： 

Beginning data sources loading: Fri Nov 14 14:39:20 CST 2014
Beginning network connect loading: Fri Nov 14 14:39:20 CST 2014
Data sources loading has finished: Fri Nov 14 14:39:24 CST 2014
Main: Configuration has been loaded: Fri Nov 14 14:39:26 CST 2014
Network connect loading has finished: Fri Nov 14 14:39:26 CST 2014

注意：如果把例3的 thread2.join(1900) 部分修改为： 

thread2.join(3000);
结果会和上面的一样吗？

根据我最开始指出的“ Thread.join()，是用来指定当前主线程等待其他线程执行完毕后，再来继续执行Thread.join()后面的代码。”

我们可以看到，执行结果会有差别：

Beginning data sources loading: Fri Nov 14 14:41:21 CST 2014
Beginning network connect loading: Fri Nov 14 14:41:21 CST 2014
Data sources loading has finished: Fri Nov 14 14:41:25 CST 2014
Network connect loading has finished: Fri Nov 14 14:41:27 CST 2014
Main: Configuration has been loaded: Fri Nov 14 14:41:27 CST 2014</span>

至于为什么会有这个差别，我上面也已经说明了，我想这个应该不难理解。

PS：代码部分截取来自《Java 7 Concurrency Cookbook》

您可能感兴趣的与本文相关的镜像

Stable-Diffusion-3.5

Stable-Diffusion-3.5

图片生成
Stable-Diffusion

Stable Diffusion 3.5 (SD 3.5) 是由 Stability AI 推出的新一代文本到图像生成模型，相比 3.0 版本，它提升了图像质量、运行速度和硬件效率

python线程join方法原理解析
12-20
本文将深入解析`join()`方法，它是控制线程执行顺序和同步的重要手段。 1. **默认线程行为** Python默认情况下，创建的线程会与主线程同步执行。这意味着，无论主线程是否执行完毕，它都会等待所有子线程执行完毕...
JAVA CountDownLatch与thread-join()的区别解析
08-25
JAVA CountDownLatch与thread-join()的区别解析 JAVA 中的线程同步机制是非常重要的，CountDownLatch 和 thread-join() 是两种常用的线程同步方法，本文将详细介绍它们之间的区别。 首先， thread-join() 方法是...
Java中Thread.join()的使用方法
08-18
主要介绍了Java中Thread.join()的使用方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java Thread.join()详解
09-18 523
一、使用方式。 join是Thread类的一个方法，启动线程后直接调用，例如： ? 1 Thread t = new AThread(); t.start(); t.join(); 二、为什么要用join()方法 在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理...
java中的join方法 转载
Java 初学者
04-26 217
原创 浅析 Java Thread.join() 收藏 一、在研究join的用法之前，先明确两件事情。 1.join方法定义在Thread类中，则调用者必须是一个线程， 例如： Thread t = new CustomThread();//这里一般是自定义的线程类 t.start();//线程起动 t.join();//此处会抛出InterruptedEx...
Thread 的 join() 方法
热门推荐
STRANGE-P 的博客
06-06 1万+
关于 Thread 的 join 方法 1、join() 方法说明2、代码演示2.1 添加 join() 方法后2.2 添加 join() 方法前2.3 对比说明3、源码理解   线程模块，计划用一个系列博文整理总结。上一篇博文：  《线程系列1：创建线程》     1、join() 方法说明   join() 是Thread的实例方...
浅谈Java线程Thread.join方法解析
08-28
Java线程Thread.join方法解析 Java线程中的join方法是一个非常重要的概念，它允许一个线程等待另一个线程的结束，以便进行后续的操作。在本篇文章中，我们将详细介绍Java线程Thread.join方法的解析和实现。 首先，...
【SystemVerilog基础】线程（fork...join、fork....join_any、fork....join_none）及线程间的通信（事件event、信号量、邮箱mailbox）
努力，加油每一天鸭~
03-18 923
【SystemVerilog基础】线程（fork...join、fork....join_any、fork....join_none）及线程间的通信（事件、信息量、邮箱）
java基本教程之join方法详解 java多线程教程
09-04
【Java多线程教程】- join方法深度解析 在Java多线程编程中，`join()`方法是一个关键的同步工具，它允许一个线程（通常为主线程）等待另一个线程（子线程）执行完毕后再继续执行。本文将详细探讨`join()`方法的原理...
Thread的join方法
最新发布
weixin_46028606的博客
06-14 1101
本文简明扼要地介绍了Java多线程编程中的join()方法。join()让调用线程等待目标线程执行完毕，常用于确保线程间有序执行。通过代码示例展示了未使用join()导致的数据错误，以及使用join()正确获取计算结果的过程。文章还介绍了带超时的join(long millis)方法，避免无限等待。关键点是：join()会阻塞当前线程，直到目标线程结束；适用于线程间存在依赖关系的场景；是Thread类的基本方法之一。
Thread之join方法
会者定离，一期一祈
02-09 1046
前言 在很多情况下，都由主线程创建并运行子线程，如果子线程中需要大量的耗时操作，主线程往往早于子线程结束。 如果主线程想等待子线程执行完成后再执行。比如子线程处理一个数据运算，而主线程想获取这个数据，可以用join方法。 public final void join() throws InterruptedException 等待该线程终止。 抛出： InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态被清除。 join() public class
Thread的join()方法
u014371381的专栏
06-19 749
join简介 join()方法是Thread类中的一个方法，该方法的定义是等待该线程终止。其实就是join()方法将挂起调用线程的执行，直到被调用的对象完成它的执行。这段话难理解，后面我会用实例做讲解。 join实例 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？这个问题是网上很热门的面试题目（这里除了用join之外还有很多其他方法能够实现，只是使用j...
Thread.join()详解
无
10-03 2821
Thread.join()详解 public final synchronized void join(long millis) throws InterruptedException { long base = System.currentTimeMillis(); long now = 0; if (millis < 0) { ...
Thread的join()
u012402926的专栏
07-11 474
本文介绍两种主线程等待子线程的实现方式，以5个子线程来说明： 　　1、使用Thread的join()方法，join()方法会阻塞主线程继续向下执行。 　　2、使用java.util.concurrent中的CountDownLatch,是一个倒数计数器。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，他的await()方法会阻塞当前进程，直到倒数至0. 　
Thread.join()
zzaric的博客
02-11 4980
线程的Thread.join 含义： 当前线程A等待thread线程终止之后才能从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(long millies,int nanos)两个具备超时特性的方法。这两个超时方法标识，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。 在下面的代码清单中...
Thread线程的join
智三岁的博客
01-15 309
java线程join的方法简单讲解 1、作用 Thread类中的join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行(也就是同时只执行一个)。具体看代码： public class JoinTest { public static void main(String [] args) throws InterruptedException { Thre...
ros_thread.join();
05-07
<think>好的，我现在需要回答用户关于ROS中ros_thread.join()的用法或相关问题。首先，我得回忆一下ROS多线程编程的相关知识。在ROS中，通常使用ros::MultiThreadedSpinner或异步spinner来处理多线程，但用户提到的是ros_thread.join()，这应该是用户自己创建了线程，并在其中运行ROS相关的代码，比如spin或者处理回调函数。 首先，我应该明确join()的作用。在C++中，std::thread的join()方法用于阻塞当前线程，直到被调用的线程执行完毕。所以当用户在ROS中创建一个线程来执行ros::spin()或其他ROS相关任务时，调用join()会确保主线程等待该子线程结束再继续执行。这在关闭节点或需要同步线程结束时很重要。 接下来，我需要考虑用户可能的代码结构。例如，用户可能有一个主线程和一个处理ROS回调的线程。主线程可能在执行其他任务，而ros_thread负责处理消息。当程序结束时，需要确保所有线程正确终止，避免资源泄漏或未定义行为。 然后，常见的问题可能包括：忘记调用join()导致线程未正确终止；在ROS节点已经关闭后仍尝试调用spin()导致错误；或者多线程环境下数据竞争的问题。这些都需要在回答中提及。 此外，我需要参考用户提供的引用内容。引用[1]中的代码是ROS1的talker节点，主循环中使用ros::spinOnce()来处理回调，但并没有显式创建线程。可能用户想了解如何在多线程中使用spin，或者如何处理线程的同步。引用[2]是关于ROS2的日志格式设置，可能与当前问题关联不大，但需要确认是否有相关线程处理的问题。 用户的问题是关于ros_thread.join()的用法和问题，所以需要具体说明在ROS1或ROS2中的情况。由于引用[1]是ROS1的代码，而引用[2]是ROS2，可能需要分别讨论。但用户这次的问题可能主要集中在ROS1，因为ros_thread可能指的是用户自己创建的线程。 可能的代码示例：用户可能创建了一个线程来执行ros::spin()，这样主线程可以继续执行其他任务。例如： ```cpp #include <ros/ros.h> #include <thread> void spinThread() { ros::spin(); } int main(int argc, char **argv) { ros::init(argc, argv, "my_node"); ros::NodeHandle nh; std::thread ros_thread(spinThread); // 主线程做其他事情 while (ros::ok()) { // ... 其他操作 } ros_thread.join(); // 等待线程结束 return 0; } ``` 这里，如果主线程在循环结束后调用join()，确保在节点关闭前线程正确结束。但需要注意，如果主线程因为ros::ok()变为false而退出循环，此时ros::spin()可能还在运行，需要正确处理。 可能出现的问题包括： 1. 线程未正确终止，导致程序无法退出。 2. 在调用join()之前没有正确关闭节点，导致线程一直阻塞。 3. 多线程中的资源竞争，比如同时访问发布者或订阅者。 解决方法可能包括： - 在节点关闭前调用ros::shutdown()，这会使得ros::spin()退出。 - 使用智能指针或条件变量来管理线程的生命周期。 - 确保线程安全，避免多个线程同时操作共享资源。 用户可能遇到的错误情况，比如在节点已经关闭后，线程仍在运行，导致段错误或其他异常。此时，调用join()可以确保线程正确结束，但需要正确触发ros::spin()的退出条件。 此外，需要提醒用户，在ROS1中，默认情况下，回调队列是单线程的，如果使用多线程处理回调，可能需要使用MultiThreadedSpinner或者设置回调队列的不同方式。而用户自己创建线程来处理spin的情况，可能适用于需要同时处理多个长时间任务的情况，比如同时处理服务请求和订阅消息。 总结回答的结构： 1. 解释ros_thread.join()的作用，即在主线程中等待子线程结束。 2. 提供使用示例，展示如何创建线程运行ros::spin()并调用join()。 3. 分析常见问题，如未调用join()导致的问题，节点关闭后的线程处理，数据竞争等。 4. 给出解决方案和最佳实践，如正确关闭节点，使用ros::shutdown()，线程同步等。 5. 生成相关问题，引导用户进一步学习。 需要确保回答符合用户的要求，结构清晰，并且引用正确的示例。同时，检查是否需要区分ROS1和ROS2的不同处理方式，但根据用户提供的引用，可能主要针对ROS1。</think>### ROS多线程编程中`ros_thread.join()`的用法解析 在ROS开发中，当需要实现多线程任务时（例如同时处理多个传感器数据），常会使用`std::thread`创建独立线程执行ROS相关操作（如消息订阅、服务调用等），此时`ros_thread.join()`的合理使用直接影响程序稳定性和资源管理。 #### 一、核心作用 `ros_thread.join()`的作用是**阻塞当前线程**（通常是主线程），直到被调用线程（如`ros_thread`）执行完毕。这保证了： 1. 线程资源安全释放 2. 避免节点关闭时的竞态条件 3. 实现有序的线程生命周期管理 #### 二、典型代码结构 ```cpp #include <ros/ros.h> #include <thread> void rosSpinThread() { ros::spin(); // 持续处理回调 } int main(int argc, char** argv) { ros::init(argc, argv, "multi_thread_node"); ros::NodeHandle nh; // 创建独立线程处理ROS回调 std::thread ros_thread(rosSpinThread); // 主线程执行其他任务 while (ros::ok()) { ROS_INFO("Main thread working..."); ros::Duration(0.5).sleep(); } ros_thread.join(); // 关键同步点 ROS_INFO("Node shutdown complete"); return 0; } ``` #### 三、常见问题与解决方案 1. **线程无法正常退出** - 现象：程序终止后线程仍在运行 - 原因：未触发`ros::spin()`退出条件 - 解决方案：在`main`函数退出前调用`ros::shutdown()` 2. **死锁风险** - 案例：主线程等待`join()`，但子线程阻塞在`ros::spin()` ```cpp // 正确关闭顺序 ros::shutdown(); // 触发spin退出 if (ros_thread.joinable()) { ros_thread.join(); } ``` 3. **数据竞争问题** - 预防措施： - 使用`std::mutex`保护共享数据 - 避免多个线程同时操作同一发布者/订阅者 - 优先使用ROS内置的线程管理（如`AsyncSpinner`） #### 四、最佳实践建议 1. **生命周期管理** ```cpp { std::thread t(...); // 作用域结束时自动join } // 错误！std::thread析构时不自动join // 正确方式 if (t.joinable()) { t.join(); } ``` 2. **异常安全处理** ```cpp try { std::thread t(...); // ... 业务代码 t.join(); } catch (...) { if (t.joinable()) t.join(); } ``` 3. **与ROS内置工具配合** ```cpp // 使用MultiThreadedSpinner替代手动线程 ros::MultiThreadedSpinner spinner(4); spinner.spin(); // 自动管理4个线程 ``` #### 五、性能优化方向 1. 通过`top -H -p <pid>`观察线程CPU占用 2. 使用`std::thread::hardware_concurrency()`获取合理线程数 3. 结合`ros::Timer`实现定时任务调度
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值