java 主线程等待子线程执行完成后再执行

最新推荐文章于 2022-06-22 10:48:02 发布
最新推荐文章于 2022-06-22 10:48:02 发布
阅读量158 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun_gufeng/article/details/84094846
版权

原文：http://www.jiacheo.org/blog/262

Java如何等待子线程执行结束

今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~

工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的产景, 这时候就需要使用线程了.

一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程,  往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式.
站在 主线程的角度, 我们可以分为主动式和被动式.
主动式指主线主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程被动的等待子线程的结束, 很明显, 比较符合人们的胃口. 就是你事情做完了, 你告诉我, 我汇总一下, 哈哈.
那么主线程如何等待子线程工作完成呢. 很简单, Thread 类给我们提供了join 系列的方法, 这些方法的目的就是等待当前线程的die. 举个例子.
public  class  Threads {

      public  static  void  main (String[]  args ) {
           SubThread thread  =  new  SubThread () ;
          thread . start () ;
          //主线程处理其他工作,让子线程异步去执行.
           mainThreadOtherWork () ;
           System . out . println ( “now waiting sub thread done.” ) ;
          //主线程其他工作完毕,等待子线程的结束, 调用join系列的方法即可(可以设置超时时间)
           try  {
              thread . join () ;
          }  catch  ( InterruptedException e) {
              e . printStackTrace () ;
          }
          System . out . println ( “now all done.” ) ;
     }

      private  static  void  mainThreadOtherWork () {
          System . out . println ( “main thread work start” ) ;
           try  {
               Thread . sleep ( 3000L ) ;
          }  catch  ( InterruptedException e) {
              e . printStackTrace () ;
          }
           System . out . println ( “main thread work done.” ) ;
     }

      public  static  class  SubThread  extends  Thread{
           @Override
           public  void  run () {
               working () ;
          }

           private  void  working () {
               System . out . println ( “sub thread start working.” ) ;
               busy () ;
               System . out . println ( “sub thread stop working.” ) ;
          }

           private  void  busy () {
               try  {
                    sleep ( 5000L ) ;
              }  catch  ( InterruptedException e) {
                   e . printStackTrace () ;
              }
          }
          
     }
}

本程序的数据有可能是如下:
  1. main thread work start
  2. sub thread start working.
  3. main thread work done.
  4. now waiting sub thread done.
  5. sub thread stop working.
  6. now all done.
忽略标号, 当然输出也有可能是1和2调换位置了. 这个我们是无法控制的. 我们看下线程的join操作, 究竟干了什么.


     public  final  void  join()  throws  InterruptedException {
     join(0) ;
    }
这里是调用了
     public  final  synchronized  void  join( long  millis) 
方法, 参数为0, 表示没有超时时间, 等到线程结束为止. join(millis)方法里面有这么一段代码:

          while  (isAlive()) {

          wait(0) ;
         }
说明, 当线程处于活跃状态的时候, 会一直等待, 直到这里的isAlive方法返回false, 才会结束.isAlive方法是一个本地方法, 他的作用是判断线程是否已经执行结束. 注释是这么写的: 

Tests if this thread is alive. A thread is alive if it has been started and has not yet died.
可见, join系列方法可以帮助我们等待一个子线程的结束.

那么要问, 有没有另外一种方法可以等待子线程结束? 当然有的, 我们可以使用并发包下面的Future模式.
Future是一个任务执行的结果, 他是一个将来时, 即一个任务执行, 立即异步返回一个Future对象, 等到任务结束的时候, 会把值返回给这个future对象里面. 我们可以使用ExecutorService接口来提交一个线程.

public  class  Threads {

      static  ExecutorService  executorService  =  Executors . newFixedThreadPool ( 1 ) ;
     
      @SuppressWarnings ( “rawtypes” )
      public  static  void  main (String[]  args )  throws  InterruptedException ,  ExecutionException {
          SubThread thread  =  new  SubThread () ;
//        thread.start();
           Future  future  =  executorService . submit (thread) ;
           mainThreadOtherWork () ;
          System . out . println ( “now waiting sub thread done.” ) ;
          future . get () ;
//        try {
//            thread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
          System . out . println ( “now all done.” ) ;
           executorService . shutdown () ;
     }

      private  static  void  mainThreadOtherWork () {
          System . out . println ( “main thread work start” ) ;
           try  {
              Thread . sleep ( 3000L ) ;
          }  catch  (InterruptedException e) {
              e . printStackTrace () ;
          }
          System . out . println ( “main thread work done.” ) ;
     }

      public  static  class  SubThread  extends  Thread{
           @Override
           public  void  run () {
               working () ;
          }

           private  void  working () {
              System . out . println ( “sub thread start working.” ) ;
               busy () ;
              System . out . println ( “sub thread stop working.” ) ;
          }

           private  void  busy () {
               try  {
                    sleep ( 5000L ) ;
              }  catch  (InterruptedException e) {
                   e . printStackTrace () ;
              }
          }
          
     }
     
}

这 里, ThreadPoolExecutor 是实现了 ExecutorService的方法, sumbit的过程就是把一个Runnable接口对象包装成一个 Callable接口对象, 然后放到 workQueue里等待调度执行. 当然, 执行的启动也是调用了thread的start来做到的, 只不过这里被包装掉了. 另外, 这里的thread是会被重复利用的, 所以这里要退出主线程, 需要执行以下shutdown方法以示退出使用线程池. 扯远了. 

这 种方法是得益于Callable接口和Future模式, 调用future接口的get方法, 会同步等待该future执行结束, 然后获取到结果. Callbale接口的接口方法是 V call(); 是可以有返回结果的, 而Runnable的 void run(), 是没有返回结果的. 所以, 这里即使被包装成Callbale接口, future.get返回的结果也是null的.如果需要得到返回结果, 建议使用Callable接口.

通过队列来控制线程的进度, 是很好的一个理念. 我们完全可以自己搞个队列, 自己控制. 这样也可以实现. 不信看代码:

public  class  Threads {

//   static ExecutorService executorService = Executors.newFixedThreadPool(1);
      static  final  BlockingQueue < Integer >  queue  =  new  ArrayBlockingQueue < Integer > ( 1 ) ;
      public  static  void  main (String[]  args )  throws  InterruptedException ,  ExecutionException {
          SubThread thread  =  new  SubThread ( queue ) ;
          thread . start () ;
//        Future future = executorService.submit(thread);
           mainThreadOtherWork () ;
          System . out . println ( “now waiting sub thread done.” ) ;
//        future.get();
           queue . take () ;
//        try {
//            thread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
          System . out . println ( “now all done.” ) ;
//        executorService.shutdown();
     }

      private  static  void  mainThreadOtherWork () {
          System . out . println ( “main thread work start” ) ;
           try  {
              Thread . sleep ( 3000L ) ;
          }  catch  (InterruptedException e) {
              e . printStackTrace () ;
          }
          System . out . println ( “main thread work done.” ) ;
     }

      public  static  class  SubThread  extends  Thread{
          
           private  BlockingQueue < Integer >  queue ;
          
           /**
           *  @param  queue
           */
           public  SubThread ( BlockingQueue < Integer >  queue ) {
               this . queue  =  queue ;
          }

           @Override
           public  void  run () {
               try {
               working () ;
              } finally {
                    try  {
                         queue . put ( 1 ) ;
                   }  catch  (InterruptedException e) {
                        e . printStackTrace () ;
                   }
              }
              
          }

           private  void  working () {
              System . out . println ( “sub thread start working.” ) ;
               busy () ;
              System . out . println ( “sub thread stop working.” ) ;
          }

           private  void  busy () {
               try  {
                    sleep ( 5000L ) ;
              }  catch  (InterruptedException e) {
                   e . printStackTrace () ;
              }
          }
          
     }
     
}

这 里是得益于我们用了一个阻塞队列, 他的put操作和take操作都会阻塞(同步), 在满足条件的情况下.当我们调用take()方法是, 由于子线程还没结束, 队列是空的, 所以这里的take操作会阻塞, 直到子线程结束的时候, 往队列里面put了个元素, 表明自己结束了. 这时候主线程的take()就会返回他拿到的数据. 当然, 他拿到什么我们是不必去关心的.
以上几种情况都是针对子线程只有1个的时候. 当子线程有多个的时候, 情况就不妙了.
第一种方法, 你要调用很多个线程的join, 特别是当你的线程不是for循环创建的, 而是一个一个创建的时候.
第二种方法, 要调用很多的future的get方法, 同第一种方法.
第三种方法, 比较方便一些, 只需要每个线程都在queue里面 put一个元素就好了.但是, 第三种方法, 这个队列里的对象, 对我们是毫无用处, 我们为了使用队列, 而要不明不白浪费一些内存, 那有没有更好的办法呢?
有的, concurrency包里面提供了好多有用的东东, 其中, CountDownLanch就是我们要用的.
CountDownLanch 是一个倒数计数器, 给一个初始值(>=0), 然后没countDown一次就会减1, 这很符合等待多个子线程结束的产景: 一个线程结束的时候, countDown一次, 直到所有都countDown了 , 那么所有子线程就都结束了.
先看看CountDownLanch有哪些方法:
await: 会阻塞等待计数器减少到0位置. 带参数的await是多了等待时间.
countDown: 将当前的技术减1
getCount(): 返回当前的计数
显而易见, 我们只需要在子线程执行之前, 赋予初始化countDownLanch, 并赋予线程数量为初始值.
每个线程执行完毕的时候, 就countDown一下.主线程只需要调用await方法, 可以等待所有子线程执行结束, 看代码:

public  class  Threads {

//   static ExecutorService executorService = Executors.newFixedThreadPool(1);
      static  final  BlockingQueue < Integer >  queue  =  new  ArrayBlockingQueue < Integer > ( 1 ) ;
      public  static  void  main (String[]  args )  throws  InterruptedException ,  ExecutionException {
           int  threads  =  5 ;
          CountDownLatch countDownLatch  =  new  CountDownLatch (threads) ;
           for ( int  i = 0 ; i < threads ; i ++ ){
              SubThread thread  =  new  SubThread ( 2000 * (i + 1 ) ,  countDownLatch) ;
              thread . start () ;
          }
//        Future future = executorService.submit(thread);
           mainThreadOtherWork () ;
          System . out . println ( “now waiting sub thread done.” ) ;
//        future.get();
//        queue.take();
          countDownLatch . await () ;
//        try {
//            thread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
          System . out . println ( “now all done.” ) ;
//        executorService.shutdown();
     }

      private  static  void  mainThreadOtherWork () {
          System . out . println ( “main thread work start” ) ;
           try  {
              Thread . sleep ( 3000L ) ;
          }  catch  (InterruptedException e) {
              e . printStackTrace () ;
          }
          System . out . println ( “main thread work done.” ) ;
     }

      public  static  class  SubThread  extends  Thread{
          
//        private BlockingQueue<Integer> queue;
           private  CountDownLatch  countDownLatch ;
           private  long  work ;
          
           /**
           *  @param  queue
           */
//        public SubThread(BlockingQueue<Integer> queue) {
//            this.queue = queue;
//            this.work = 5000L;
//        }
          
           public  SubThread ( long  work ,  CountDownLatch  countDownLatch ) {
//            this.queue = queue;
               this . countDownLatch  =  countDownLatch ;
               this . work  =  work ;
          }

           @Override
           public  void  run () {
               try {
               working () ;
              } finally {
//                 try {
//                      queue.put(1);
//                 } catch (InterruptedException e) {
//                      e.printStackTrace();
//                 }
                    countDownLatch . countDown () ;
              }
              
          }

           private  void  working () {
              System . out . println ( getName () + ” sub thread start working.” ) ;
               busy () ;
              System . out . println ( getName () + ” sub thread stop working.” ) ;
          }

           private  void  busy () {
               try  {
                    sleep ( work ) ;
              }  catch  (InterruptedException e) {
                   e . printStackTrace () ;
              }
          }
          
     }
}
此种方法也适用于使用 ExecutorService summit 的任务的执行.
另外还有一个并发包的类CyclicBarrier, 这个是(子)线程之间的互相等待的利器. 栅栏, 就是把大家都在一个地方堵住, 就像水闸, 等大家都完成了之前的操作, 在一起继续下面的操作. 不过就不再本篇的讨论访问内了.
EOF
sun_gufeng
关注
专栏目录
c++主线程等待子线程结束_主线程等待子线程完成后执行的实现方式
weixin_39644021的博客
12-21 1213
被面试是一种狠高效的学习方式。前几天被人面试问到了，我当时直接说用CountDownLatch(后面就呵呵了...)后来阅读了点资料，仔细想了想总结如下。古老的wait notify下面是一个报错的例子。其实完全可以用这种古老的wait notify方式实现。可能用法不太对，欢迎指正。public class ThreadANTest {public static void main(String...
Java多线程--让主线程等待所有子线程执行完毕
09-09
Java多线程--让主线程等待所有子线程执行完毕
Java主线程等待子线程执行完毕
05-24
非常实用不解释，用了才知道 个人收藏的一部分资料将陆续给大家上传
主线程等待子线程执行完毕后再执行
yehexing3的专栏
03-25 660
//Main主线程   public class MainThread {            public static void main(String[] args) throws InterruptedException {            longstartTime = System.currentTimeMillis();            intthreadNu
java主线程等待所有子线程执行完毕再执行
热门推荐
延宝小白马的博客
07-18 5万+
        java主线程等待所有子线程执行完毕在执行，这个需求其实我们在工作中经常会用到，比如用户下单一个产品，后台会做一系列的处理，为了提高效率，每个处理都可以用一个线程来执行，所有处理完成了之后才会返回给用户下单成功，下面就说一下我能想到的方法，欢迎大家批评指正： 1  用sleep方法，让主线程睡眠一段时间，当然这个睡眠时间是主观的时间，是我们自己定的，这个方法不推荐，但是在这里还是...
Java主线程等待所有子线程执行完毕再执行解决办法（转）
weixin_33843947的博客
11-09 239
方法一： Thread.join()方法，亲测可行，thread.join()方法   [java] view plain copy   Vector&lt;Thread&gt; ts = new Vector&lt;Thread&gt;();           for (int i = 0; i &lt; 200; i++) {               T...
主线程等待所有子线程执行完毕后再执行
iteye_12240的博客
06-28 221
主线程等待所有子线程执行完毕后再执行主线程，需要用到线程计数器java.util.concurrent.CountDownLatch;也可以使用join()方法,但join()方法是同步的，失去了线程并发的意义。所以，一般情况下建议使用线程计数器。 [code="java"]public class TestThread implements Runnable{ //...
JAVA主线程等待子线程执行完毕再执行[参照].pdf
10-11
JAVA 主线程等待子线程执行完毕再执行 JAVA 中的线程控制是非常重要的一部分，而在实际开发中，我们经常会遇到需要主线程等待子线程执行完毕再执行的情况。这种情况下，我们可以使用两种方式来实现：主动式和被动式...
Java简单实现“主线程等待所有子线程完成再继续”
03-25
总的来说，Java提供了丰富的多线程同步机制，可以根据实际需求选择合适的方法来实现“主线程等待所有子线程完成再继续”的功能。在并发编程中，理解并灵活运用这些工具对于提高程序效率和避免死锁等问题至关重要。
Java多线程–让主线程等待所有子线程执行完毕
12-22
要解决“让主线程等待所有子线程执行完毕”的问题，可以采用以下策略： 1. 使用`join()`方法：如提到的，直接在每个子线程的`start()`之后调用`t.join()`，会导致所有线程按顺序执行。这是因为`join()`会让主线程...
Java实现等待所有子线程结束后再执行一段代码的方法
08-29
在 Java 中，实现等待所有子线程结束后再执行一段代码是非常重要的，因为它可以确保主线程等待所有子线程完成任务后再继续执行。这篇文章将详细介绍 Java 实现等待所有子线程结束后再执行一段代码的方法。 ...
多线程-主线程等待子线程都执行结束再执行
weixin_43979189的博客
06-30 2074
多线程-主线程等待子线程都执行结束再执行 有三种方式可以实现： 使用Thread的join()等待所有的子线程执行完毕，主线程在执行； 等待多线程完成的CountDownLatch； 同步屏障CyclicBarrier； 一、使用Thread的join() ​ 使用Thread的join()等待所有的子线程执行完毕，主线程在执行，thread.join()把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继
主线程等待子线程执行完毕再执行方法
我的博客
04-27 5111
public static v...
java 主线程等待_问题：如何实现java主线程等待子线程执行完毕之后再执行？
weixin_32289847的博客
02-16 462
工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的场景, 这时候就需要使用线程了.一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程, 往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式.站在主线程的角度, 我们可以分为主动式和被动式.主动式指主线程主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程...
如何让主线程等待子线程执行完毕后再执行
qq_42251944的博客
06-22 2569
总结三个方法：（1）join方法，直接将每个线程都join进去即可。（2）ountdownlatch，内部维持一个计数操作，通过cas算法保证操作的原子性，当线程执行完之后，调用countDown()方法，将计数减一，主线程调用countdownlatch对象的await()方法，将当前线程挂起，直到countdownlatch对象的计数为0，主线程执行。（3）类似屏障的东西，当子线程执行完之后，调用CyclicBarrier对象的await()方法，直到指定数量的线程到达屏障之后，才会继续执行主线程。把每
【多线程】学习记录七种主线程等待子线程结束之后在执行的方法
Wan_Yuan的博客
10-19 1407
最近遇到一个问题需要主线程等待所有的子线程结束，才能开始执行，统计所有的子线程执行结果，返回，网上翻阅各种资料，最后记录一下，找到七种方案 第一种：while循环 对于“等待所有的子线程结束”的问题，最开始想到的是使用while循环进行轮询： //开始计时 String start = getTheTimeInMilliseconds(); System.out.println("start = " + start); Thread t = n
面试官：如何让主线程等待所有的子线程执行结束之后再执行
养歌的博客
01-12 4893
java 主线程等待所有子线程执行完毕在执行，在工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总（比如用户下单一个产品，后台会做一系列的处理，为了提高效率，每个处理都可以用一个线程来执行，所有处理完成了之后才会返回给用户下单成功）的场景, 这时候就需要使用线程了。 解决方法 sleep 用 sleep 方法，让主线程睡眠一段时间，让其它子线程先执行，虽然也是解决的方法，但是不推荐使用。 public class ThreadTest extends Thre
如何实现java主线程等待子线程执行完毕之后再执行？
强哥叨逼叨
03-11 5285
本文转自：问题：如何实现java主线程等待子线程执行完毕之后再执行？ - jseven - 博客园 点击关注强哥，查看更多精彩文章呀 工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑的处理结果进行汇总的场景, 这时候就需要使用线程了. 　　一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程, 往往需要让主线程指定后, 等待子线程的完成. 这里有几种方式. 　　站在主线程的角度, 我们可以分为主动式和被动式. 　　主动式指主线程主动去检测某个.
面试官：如何让主线程等待所有的子线程结束之后再执行？我懵了
骏马逸动，心随你动的博客
07-12 799
使用Thread的join方法 package com.qcy.testThreadFinish; /** * @author qcy * @create 2020/09/09 17:05:23 */ public class Case1 { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> {
java需要主线程等待子线程执行完毕后再执行，有哪些方法可以实现
最新发布
04-07
1. 使用Thread.join()方法，可以让主线程等待子线程执行完毕后再继续执行。 2. 使用CountDownLatch类，可以让主线程等待一组线程执行完毕后再继续执行。 3. 使用Future和Callable接口，可以让主线程等待子线程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值