Java主线程等待子线程、线程池完成

最新推荐文章于 2024-12-06 11:57:18 发布
最新推荐文章于 2024-12-06 11:57:18 发布
阅读量752 收藏
点赞数
分类专栏： 多线程编程
本文深入探讨了Java中线程池、CountDownLatch等并发工具的使用，详细解释了如何实现主线程等待子线程执行完成，以及如何在等待多个线程时利用线程池和CountDownLatch进行高效管理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程池 主线程 子线程 CountDownLatch ExecutorService
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class TestThread extends Thread  
  2. {  
  3.     public void run()  
  4.     {  
  5.         System.out.println(this.getName() + "子线程开始");  
  6.         try  
  7.         {  
  8.             // 子线程休眠五秒  
  9.             Thread.sleep(5000);  
  10.         }  
  11.         catch (InterruptedException e)  
  12.         {  
  13.             e.printStackTrace();  
  14.         }  
  15.         System.out.println(this.getName() + "子线程结束");  
  16.     }  
  17. }  

首先是一个线程，它执行完成需要5秒。

1、主线程等待一个子线程

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         Thread thread = new TestThread();  
  8.         thread.start();  
  9.           
  10.         long end = System.currentTimeMillis();  
  11.         System.out.println("子线程执行时长：" + (end - start));  
  12.     }  
  13. }  

在主线程中，需要等待子线程执行完成。但是执行上面的main发现并不是想要的结果：

子线程执行时长：0
Thread-0子线程开始
Thread-0子线程结束

很明显主线程和子线程是并发执行的，主线程并没有等待。

对于只有一个子线程，如果主线程需要等待子线程执行完成，再继续向下执行，可以使用Thread的join()方法。join()方法会阻塞主线程继续向下执行。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         Thread thread = new TestThread();  
  8.         thread.start();  
  9.           
  10.         try  
  11.         {  
  12.             thread.join();  
  13.         }  
  14.         catch (InterruptedException e)  
  15.         {  
  16.             e.printStackTrace();  
  17.         }  
  18.           
  19.         long end = System.currentTimeMillis();  
  20.         System.out.println("子线程执行时长：" + (end - start));  
  21.     }  
  22. }  

执行结果：

Thread-0子线程开始
Thread-0子线程结束
子线程执行时长：5000

注意：join()要在start()方法之后调用。

2、主线程等待多个子线程

比如主线程需要等待5个子线程。这5个线程之间是并发执行。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         for(int i = 0; i < 5; i++)  
  8.         {  
  9.             Thread thread = new TestThread();  
  10.             thread.start();  
  11.               
  12.             try  
  13.             {  
  14.                 thread.join();  
  15.             }  
  16.             catch (InterruptedException e)  
  17.             {  
  18.                 e.printStackTrace();  
  19.             }  
  20.         }  
  21.           
  22.         long end = System.currentTimeMillis();  
  23.         System.out.println("子线程执行时长：" + (end - start));  
  24.     }  
  25. }  

在上面的代码套上一个for循环，执行结果：

Thread-0子线程开始
Thread-0子线程结束
Thread-1子线程开始
Thread-1子线程结束
Thread-2子线程开始
Thread-2子线程结束
Thread-3子线程开始
Thread-3子线程结束
Thread-4子线程开始
Thread-4子线程结束
子线程执行时长：25000

由于thread.join()阻塞了主线程继续执行，导致for循环一次就需要等待一个子线程执行完成，而下一个子线程不能立即start()，5个子线程不能并发。

要想子线程之间能并发执行，那么需要在所有子线程start()后，在执行所有子线程的join()方法。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         List<Thread> list = new ArrayList<Thread>();  
  8.         for(int i = 0; i < 5; i++)  
  9.         {  
  10.             Thread thread = new TestThread();  
  11.             thread.start();  
  12.             list.add(thread);  
  13.         }  
  14.           
  15.         try  
  16.         {  
  17.             for(Thread thread : list)  
  18.             {  
  19.                 thread.join();  
  20.             }  
  21.         }  
  22.         catch (InterruptedException e)  
  23.         {  
  24.             e.printStackTrace();  
  25.         }  
  26.           
  27.         long end = System.currentTimeMillis();  
  28.         System.out.println("子线程执行时长：" + (end - start));  
  29.     }  
  30. }  

执行结果：

Thread-0子线程开始
Thread-3子线程开始
Thread-1子线程开始
Thread-2子线程开始
Thread-4子线程开始
Thread-3子线程结束
Thread-0子线程结束
Thread-2子线程结束
Thread-1子线程结束
Thread-4子线程结束
子线程执行时长：5000

3、主线程等待多个子线程（CountDownLatch实现）

CountDownLatch是java.util.concurrent中的一个同步辅助类，可以把它看做一个倒数计数器，就像神舟十号发射时倒数：10,9,8,7….2,1,0,走你。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，await()方法会阻塞当前进程，直到倒数至0。

同样还是主线程等待5个并发的子线程。修改上面的代码，在主线程中，创建一个初始值为5的CountDownLatch，并传给每个子线程，在每个子线程最后调用countDown()方法对倒数器减1，当5个子线程等执行完成，那么CountDownLatch也就倒数完成，主线程调用await()方法等待5个子线程执行完成。

修改MyThread接收传入的CountDownLatch：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class TestThread extends Thread    
  2. {    
  3.     private CountDownLatch countDownLatch;    
  4.             
  5.     public TestThread(CountDownLatch countDownLatch)    
  6.     {    
  7.         this.countDownLatch = countDownLatch;    
  8.     }    
  9.   
  10.     public void run()    
  11.     {    
  12.         System.out.println(this.getName() + "子线程开始");    
  13.         try    
  14.         {    
  15.             // 子线程休眠五秒    
  16.             Thread.sleep(5000);    
  17.         }    
  18.         catch (InterruptedException e)    
  19.         {    
  20.             e.printStackTrace();    
  21.         }  
  22.   
  23.         System.out.println(this.getName() + "子线程结束");  
  24.             
  25.         // 倒数器减1  
  26.         countDownLatch.countDown();  
  27.     }  
  28. }  
修改main：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         // 创建一个初始值为5的倒数计数器  
  8.         CountDownLatch countDownLatch = new CountDownLatch(5);  
  9.         for(int i = 0; i < 5; i++)  
  10.         {  
  11.             Thread thread = new TestThread(countDownLatch);  
  12.             thread.start();  
  13.         }  
  14.           
  15.         try  
  16.         {  
  17.             // 阻塞当前线程，直到倒数计数器倒数到0  
  18.             countDownLatch.await();  
  19.         }  
  20.         catch (InterruptedException e)  
  21.         {  
  22.             e.printStackTrace();  
  23.         }  
  24.           
  25.         long end = System.currentTimeMillis();  
  26.         System.out.println("子线程执行时长：" + (end - start));  
  27.     }  
  28. }  
执行结果：

Thread-0子线程开始
Thread-2子线程开始
Thread-1子线程开始
Thread-3子线程开始
Thread-4子线程开始
Thread-2子线程结束
Thread-4子线程结束
Thread-1子线程结束
Thread-0子线程结束
Thread-3子线程结束
子线程执行时长：5000

注意：如果子线程中会有异常，那么countDownLatch.countDown()应该写在finally里面，这样才能保证异常后也能对计数器减1，不会让主线程永远等待。

另外，await()方法还有一个实用的重载方法：public booleanawait(long timeout, TimeUnit unit)，设置超时时间。

例如上面的代码，想要设置超时时间10秒，到了10秒无论是否倒数完成到0，都会不再阻塞主线程。返回值是boolean类型，如果是超时返回false，如果计数到达0没有超时返回true。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. // 设置超时时间为10秒  
  2. boolean timeoutFlag = countDownLatch.await(10,TimeUnit.SECONDS);  
  3. if(timeoutFlag)  
  4. {  
  5.     System.out.println("所有子线程执行完成");  
  6. }  
  7. else  
  8. {  
  9.     System.out.println("超时");  
  10. }  
4、主线程等待线程池

Java线程池java.util.concurrent.ExecutorService是很好用的多线程管理方式。ExecutorService的一个方法boolean awaitTermination(long timeout, TimeUnit unit)，即阻塞主线程，等待线程池的所有线程执行完成，用法和上面所说的CountDownLatch的public boolean await(long timeout,TimeUnit unit)类似，参数设置一个超时时间，返回值是boolean类型，如果超时返回false，如果线程池中的线程全部执行完成，返回true。

由于ExecutorService没有类似CountDownLatch的无参数的await()方法，只能通过awaitTermination来实现主线程等待线程池。

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Main  
  2. {  
  3.     public static void main(String[] args)  
  4.     {  
  5.         long start = System.currentTimeMillis();  
  6.           
  7.         // 创建一个同时允许两个线程并发执行的线程池  
  8.         ExecutorService executor = Executors.newFixedThreadPool(2);  
  9.         for(int i = 0; i < 5; i++)  
  10.         {  
  11.             Thread thread = new TestThread();  
  12.             executor.execute(thread);  
  13.         }  
  14.         executor.shutdown();  
  15.           
  16.         try  
  17.         {  
  18.             // awaitTermination返回false即超时会继续循环，返回true即线程池中的线程执行完成主线程跳出循环往下执行，每隔10秒循环一次  
  19.             while (!executor.awaitTermination(10, TimeUnit.SECONDS));  
  20.         }  
  21.         catch (InterruptedException e)  
  22.         {  
  23.             e.printStackTrace();  
  24.         }  
  25.           
  26.         long end = System.currentTimeMillis();  
  27.         System.out.println("子线程执行时长：" + (end - start));  
  28.     }  
  29. }  
执行结果：

Thread-0子线程开始
Thread-1子线程开始
Thread-0子线程结束
Thread-2子线程开始
Thread-1子线程结束
Thread-3子线程开始
Thread-2子线程结束
Thread-4子线程开始
Thread-3子线程结束
Thread-4子线程结束
子线程执行时长：15000

另外，while(!executor.isTerminated())也可以替代上面的while (!executor.awaitTermination(10,TimeUnit.SECONDS))，isTerminated()是用来判断线程池是否执行完成。但是二者比较我认为还是awaitTermination更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

【项目开发 | Java】实现主线程等待子线程及线程池
等风来
11-10 1558
在这种情况下，主线程需要等待所有子线程的执行结果，以便在客户端请求完成后返回完整的响应。在批量数据库查询中，主线程等待多个数据库查询子线程的结果，合并所有结果后再返回给客户端，这就是个贴近业务场景的例子。这样，子线程可以并发执行，主线程会等待它们全部完成后，再输出总执行时长。在这段代码中，我们希望在子线程执行完成后，主线程输出子线程的执行时长。会强制主线程在每次循环中等待一个子线程执行完成，从而使得所有子线程顺序执行，而非并发执行。这表明主线程和子线程是并发执行的，主线程并没有等待子线程完成。
在Java线程池中 主线程等待子线程完成任务 并返回
telltao的博客
07-08 1980
Java创建一个固定长度的线程池执行业务逻辑完成 创建一个固定长度的线程池 /** * <pre> * Create By Liu Tao * 创建一个线程池，该线程池重用在共享无界队列上运行的固定数量的线程。 * 在任何时候，大多数Threads线程都是活动的处理任务。 * 如果在所有线程都处于活动状态时提交其他任务，它们将在...
Java简单实现“主线程等待所有子线程完成再继续”
03-25
NULL 博文链接：https://zhaoningbo.iteye.com/blog/1158225
Java主线程等待子线程、线程池
移动编程
07-01 395
public class TestThread extends Thread { public void run() { System.out.println(this.getName() + "子线程开始"); try { // 子线程休眠五秒 Thread.sleep(5000); } catch (InterruptedException e) { ...
主线程等待线程池所有任务完成
十万小时之旅
09-22 505
原文出处：http://blog.chenlb.com/2008/12/main-thread-wait-all-sub-thread-finish-task-in-thread-pool.html 用线程池编写多线程程序时，当所有任务完成时，要做一些统计的工作。而统计工作必须要在所有任务完成才能做。所以要让主线程等待所有任务完成。可以使用ThreadPoolExecutor.await...
Java实现主线程等待子线程
热门推荐
My Blog
06-11 2万+
本文介绍两种主线程等待子线程的实现方式，以5个子线程来说明： 1、使用Thread的join()方法，join()方法会阻塞主线程继续向下执行。 2、使用java.util.concurrent中的CountDownLatch，是一个倒数计数器。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，他的await()方法会阻塞当前进程，直到倒数至0。 join方
JAVA主线程等待子线程执行完毕再执行[参照].pdf
10-11
JAVA 主线程等待子线程执行完毕再执行 JAVA 中的线程控制是非常重要的一部分，而在实际开发中，我们经常会遇到需要主线程等待子线程执行完毕再执行的情况。这种情况下，我们可以使用两种方式来实现：主动式和被动式...
主线程等待子多线程(无结果返回)执行完成再继续执行
06-09
"主线程等待子多线程(无结果返回)执行完成再继续执行"这个主题就涉及到如何在Java、C#、Python等编程语言中实现这种同步机制。下面将详细讨论这个知识点。 **1. Java中的`Thread.join()`方法** 在Java中，主线程...
java 主线程等待子线程结束
xuejianxinokok的专栏
09-12 2505
第一种方式join/** * Date:2016年9月7日下午7:43:13 * Copyright (c) 2016, www.bwbroad.com All Rights Reserved. * */ package test.join; import test.Task; /** * Description: TODO * Date: 2016年9月7日 下午7:4
java 主线程等待_Java实现主线程等待子线程
weixin_42138703的博客
02-12 335
本文介绍两种主线程等待子线程的实现方式，以5个子线程来说明：1、使用Thread的join()方法，join()方法会阻塞主线程继续向下执行。2、使用Java.util.concurrent中的CountDownLatch，是一个倒数计数器。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，他的await()方法会阻塞当前进程，直到倒数至0。join方式代码如下：...
Java 中实现主线程等待子线程
qq_41893505的博客
12-06 325
通过 Future 的 get()，ExecutorService 的 submit() 方法返回一个 Future 对象，可以通过 Future.get() 阻塞等待任务完成。invokeAll() 方法，ExecutorService 提供了 invokeAll() 方法，可以一次性提交一组任务，并阻塞直到所有任务完成。使用 CountDownLatch，通过线程池配合 CountDownLatch 实现主线程等待所有任务完成。
主线程等待线程池结束
iteye_4755的博客
08-06 307
http://dongdong1314.blog.51cto.com/389953/224932/ 所有SynchronousQueue，它将任务直接提交给线程而不保持它们。在此，如果不存在可用于立即运行任务的线程，则试图把任务加入队列将失败，因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝...
java 主线程等待_Java：主线程和子线程—–主线程等待子线程结束 | 学步园
weixin_29722783的博客
02-20 304
想做的一个程序如题，主要是想统计子线程都执行完毕所用的时间，网上搜索到了CountDownLatch这个类，这个工具类可以理解为计数器。在这里用于表示正在运行的线程数，当一个子线程结束的时候，将这个计数器减一，最后在主线程的一个地方等待子线程全部执行完毕，再继续运行等待后面的程序。写了个Demo程序，如下：//子线程public class SubThread extends Thread{//子...
Java多线程--让主线程等待子线程执行完毕
weixin_41017246的博客
10-10 305
参考链接：https://www.cnblogs.com/eoss/p/5902939.html 使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行，那么接下来介绍一种简单的方式使主线程等待。 java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待： public...
Java主线程等待子线程执行完毕-CountDownLatch
过往记忆大数据
12-11 6494
主线程：   //Main主线程 publicclassMainThread { publicstaticvoid main(String[] args) throwsInterruptedException { longstartTime = System.currentTimeMillis(); intthreadNum =
java主线程如和等待线程池执行完毕
最新发布
03-18
<think>好的，我现在需要帮助用户解决Java中主线程如何等待线程池执行完成的问题。用户提到了join方法、shutdown和awaitTermination，我需要结合这些关键词给出清晰的解答。首先，我应该回忆一下Java多线程的相关知识，特别是线程池的管理和同步机制。 首先，用户提到的join方法。我记得Thread类的join方法可以让主线程等待子线程结束，但线程池中的线程通常是通过ExecutorService管理的，不能直接获取到每个线程的引用，所以直接使用join可能不太适用。这点需要说明清楚，避免用户混淆。 然后是shutdown和awaitTermination。线程池的shutdown方法会启动有序关闭，不再接受新任务，但已提交的任务会继续执行。而awaitTermination则是阻塞主线程，直到所有任务完成或者超时。不过要注意，shutdown之后必须调用awaitTermination才能真正等待，否则主线程可能立即继续执行。同时，需要处理可能的InterruptedException异常。 接下来，用户可能没有提到的其他方法，比如CountDownLatch。这是并发工具类中的一个同步辅助器，可以在每个任务完成时递减计数器，主线程等待计数器归零。这种方法更灵活，尤其适用于需要明确知道所有任务完成的场景。此外，Future的get方法也可以用来等待任务完成，但如果是多个任务的话，可能需要遍历所有Future对象，逐一调用get，这可能会比较繁琐，或者使用invokeAll方法。 还有，使用shutdown结合isTerminated轮询检查的方法，虽然不推荐，但在某些情况下可能适用。需要指出这种方法的缺点，比如忙等待可能消耗CPU资源。 现在需要整理这些方法，按推荐的顺序进行说明，可能从最基础的Thread.join到高级工具类。但考虑到用户的问题是关于线程池的，应该重点放在ExecutorService的方法和CountDownLatch上。 需要注意的是，线程池中的线程默认是守护线程，如果主线程不等待的话，可能会提前退出，导致子线程未完成就被终止。因此，正确的等待机制非常重要。 另外，需要给出示例代码，帮助用户理解如何具体实现。比如使用awaitTermination时，先调用shutdown，然后循环调用awaitTermination，直到返回true或者超时。或者使用CountDownLatch，在每个任务完成时调用countDown()。 可能还需要比较不同方法的优缺点，比如使用CountDownLatch可以更精确地控制，而awaitTermination依赖于线程池的正确关闭。同时，要提醒用户处理异常情况，比如任务执行过程中抛出异常，是否会影响等待机制。 最后，生成相关问题，比如如何判断线程池是否完成，或者如何处理任务中的异常，这些都能帮助用户进一步学习。</think>在Java中，主线程等待线程池执行完毕主要有以下四种实现方式，按推荐优先级排序： ### 一、使用`awaitTermination`方法（推荐） 1. 调用`shutdown()`关闭线程池 2. 配合`awaitTermination()`实现等待 ```java ExecutorService executor = Executors.newFixedThreadPool(4); // 提交任务... executor.shutdown(); // 停止接收新任务 try { // 循环等待直到所有任务完成 while (!executor.awaitTermination(60, TimeUnit.SECONDS)) { System.out.println("等待任务完成..."); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } ``` **优势**：官方推荐方式，可设置超时时间避免无限阻塞[^2] ### 二、使用`CountDownLatch`（精确控制） 1. 创建计数器（任务数量为初始值） 2. 每个任务完成后计数器减1 ```java CountDownLatch latch = new CountDownLatch(10); ExecutorService executor = Executors.newFixedThreadPool(4); for (int i = 0; i < 10; i++) { executor.submit(() -> { try { // 执行任务... } finally { latch.countDown(); // 必须放在finally块 } }); } try { latch.await(); // 主线程等待 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } ``` **特点**：精确控制等待的任务数量，适合已知任务总数的情况[^3] ### 三、使用`Future`+`get()`方法 ```java List<Future<?>> futures = new ArrayList<>(); ExecutorService executor = Executors.newFixedThreadPool(4); for (int i = 0; i < 10; i++) { futures.add(executor.submit(() -> { // 执行任务... })); } try { for (Future<?> future : futures) { future.get(); // 阻塞获取结果 } } catch (ExecutionException | InterruptedException e) { // 异常处理 } ``` ### 四、不推荐的方式：`join`方法 $$注意：线程池中的工作线程无法直接获取Thread对象，因此join方法不适用于线程池场景$$ ### 对比表格 | 方法 | 适用场景 | 超时控制 | 异常处理 | 资源释放 | |--------------------|-------------------------|--------|--------|--------| | awaitTermination | 通用场景 | 支持 | 自动 | 自动 | | CountDownLatch | 精确控制任务数量 | 支持 | 手动 | 手动 | | Future.get() | 需要获取任务结果 | 支持 | 自动 | 自动 | | isTerminated轮询 | 需要实时监控 | 支持 | 手动 | 自动 | **最佳实践建议**：优先使用`awaitTermination`+`shutdown`组合，需要获取任务结果时配合`Future`使用，精确控制任务完成数量时使用`CountDownLatch`[^4]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值