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

最新推荐文章于 2023-11-20 16:54:36 发布
最新推荐文章于 2023-11-20 16:54:36 发布
阅读量620 收藏
点赞数
分类专栏： 多线程编程
线程池 主线程 子线程 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更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

R先森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java线程池&子线程&事务&异步返回监听实战
10-20
在java开发中，往往会遇到一个请求需要处理很多次数据库，想要分成多个线程异步处理，在此给出个一个试例完成上述需求，子事务的成败会控制主线程的事务，并利用了CompletableFuture实现异步监听，@Async注解实现了线程池的应用。
ExecutorService java线程池主线程等待子线程执行完成
bincavin的专栏
11-09 4497
java1.5及1.6中通过ExecutorService提供了线程池的支持。我们可以按照如下的方法建立10个线程容量的线程池： ExecutorService exec = Executors.newFixedThreadPool(10); for (i = 0; i < taskAmount; i++)
主线程等待子线程执行完成的三种方法介绍
fanfan_v5的博客
03-19 3224
举个场景，用户表t_user根据userid做了分库分表，数据散列在了三个库表里t_user1、t_user2、t_user3，此时的count(t_user)需要count(t_user1) + count(t_user2) + count(t_user3)。我们为了提高性能，减少count(t_user)的响应时长，可以通过多线程并行执行各个子count，然后在主线程里将各个子任务的结果集进行
java线程池主线程等待子线程执行完成
热门推荐
yaowj2的专栏
04-06 2万+
原文：http://www.jiacheo.org/blog/262  Java如何等待子线程执行结束 今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了. 一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的
java单独开子线程，不等待操作结束直接返回调用成功
草叶儿的博客
10-18 2049
@Override public Result tow() { Thread thread = new Thread(() -> {//里边写需要的操作。return之后也不停止运行，直到结束 while (1 == 1) { System.out.println(1); } }); thread.start(); return new Re...
Java主线程等待子线程、线程池
移动编程
07-01 317
public class TestThread extends Thread { public void run() { System.out.println(this.getName() + "子线程开始"); try { // 子线程休眠五秒 Thread.sleep(5000); } catch (InterruptedException e) { ...
关于主线程等待子线程的问题
weixin_40267415的博客
01-14 641
线程本身就是被看作独立的执行片断。主线程不会等待子线程的   //同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。 //在构造CountDownLatch的时候需要传入一个整数n，在这个整数“倒数”到0之前， // 主线程需要等待在门口，而这个“倒数”过程则是由各个执行线程驱动的，每个线程执行完一个任务“倒数”一次。 // 总结来说，CountDownLat...
java主线程等待子线程池执行完再执行
weixin_43873239的博客
11-20 245
是 Java 中用于等待线程池中的所有任务执行完毕的方法。这个方法通常用于在程序结束前确保所有任务都已经完成，例如在服务器关闭之前。来阻塞当前线程，直到所有任务完成执行，或者超时，或者当前线程被中断。方法来等待线程池中的所有任务执行完毕。以下是一个简单的示例。如果等待过程中当前线程被中断，它会抛出。如果线程池在指定的时间内关闭，或者调用。来创建一个线程池，并使用。在Java中，你可以使用。如果超时期限到达，返回。
java使用多线程时，主线程等待子现场执行完再执行
qq_29660549的博客
07-09 1397
java使用多线程时，主线程等待子现场执行完再执行 1.问题演示 public static void main(String[] args) { // 创建Runnable实例对象 Runnable runnable = ()->{ System.out.println("我要一个教练"); try { Thread.sleep(1000); } catch (In
Java多线程–让主线程等待所有子线程执行完毕
12-22
　数据量很大百万条记录，因此考虑到要用多线程并发执行，在写的过程中又遇到问题，我想统计所有子进程执行完毕总共的耗时，在第一个子进程创建前记录当前时间用System.currentTimeMillis（）在后一个子进程结束后...
基于Java子线程中的异常处理方法(通用)
08-29
下面小编就为大家带来一篇基于Java子线程中的异常处理方法(通用)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
java大批量导入excel，多线程加分片处理的dome
09-12
然后，创建一个固定数量的线程池，使用 CountDownLatch 控制主线程等待所有任务完成；最后，循环迭代分片区间，将分片任务提交到线程池中处理。在每个任务中，使用 ReadRowHolder 对象实现分片读取 Excel 数据，并...
Java进阶学习——Java多线程知识的理解
01-20
Java多线程知识的理解0.前言1.从一道题目引入2.创建线程2.1.继承Thread类2.2.实现Runnable接口3.线程的生命周期4.线程安全4.1.为什么需要线程安全？4.2.如何实现线程安全？...为什么主线程早于子线
自动驾驶运动规划(Motion Planning).pdf
04-26
自动驾驶运动规划(Motion Planning)问题分析
财务数据分析模型6.xlsx
04-26
Excel数据看板，Excel办公模板，Excel模板下载，Excel数据统计，数据展示
人力资源数据分析看版.xlsx
04-26
Excel数据看板，Excel办公模板，Excel模板下载，Excel数据统计，数据展示
重庆大学2011-2012(2)数字电子技术II.pdf
最新发布
04-26
重庆大学期末考试试卷，重大期末考试试题，试题及答案
随波逐流CTF编码工具 V5.6 20240424.rar
04-26
由随波逐编写开发，CTF编码工具为用户提供丰富的离线加密解密功能，还可以对字符编码进行转换，文件隐写查看，用户可以根据自己的需求来使用功能，非常实用，能够提高大家的工作效率！
java 主线程等待线程池任务执行完成再往下执行
04-24
当主线程需要等待线程池任务执行完成后再往下执行的情况下，可以通过使用CountDownLatch或Future来实现。 如果使用CountDownLatch，可以在主线程中创建一个CountDownLatch对象，并设置它的计数器值为线程池中任务的数量。每一个任务执行完成后，都将计数器的值减1。主线程可以通过调用CountDownLatch.await()方法来等待所有任务完成。当计数器的值变为0时，await()方法会返回，主线程就可以继续执行后续操作。 如果使用Future，可以在主线程中提交所有任务到线程池，并将返回的Future对象保存在一个列表中。主线程可以通过Future的get()方法来等待任务执行完成。当所有任务都执行完成后，主线程就可以继续执行后续操作。 需要注意的是，在使用线程池的过程中，一定要及时释放线程资源，避免线程泄漏。同时，合理地设置线程池的大小和配置项，也可以提高程序的执行效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值