如何让主线程等待所有的子线程结束之后再执行

本篇内容主要讲解“如何让主线程等待所有的子线程结束之后再执行”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“如何让主线程等待所有的子线程结束之后再执行”吧!

使用Thread的join方法

package com.qcy.testThreadFinish;   public class Case1 {     public static void main(String[] args) throws InterruptedException {          Thread t1 = new Thread(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }         });         t1.start();          Thread t2 = new Thread(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }         });         t2.start();          t1.join();         t2.join();         System.out.println("主线程结束");     } }

join()方法使得主线程等待子线程执行结束，阻塞的是主线程。其底层原理，可以参考我的这篇文章你真得懂Thread.join吗?

使用线程池的isTerminated方法

package com.qcy.testThreadFinish;  import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;   public class Case2 {     public static void main(String[] args) {          ExecutorService pool = Executors.newFixedThreadPool(3);          pool.execute(() -> {             try {                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }         });          pool.execute(() -> {             try {                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }         });          //不再接受新的任务         pool.shutdown();                  while (true) {             //手动循环确实效率很低，不推荐             if (pool.isTerminated()) {                 System.out.println("线程池中的任务执行结束");                 break;             }         }         System.out.println("主线程结束");     } }

isTerminated，当调用shutdown()方法后，并且所有提交的任务完成后才会返回为true

这里直接使用了固定大小的线程池，线程池的参数在面试中也经常被问到，对线程池不熟悉的同学，可以参考我的这篇文章说说线程池

使用Future机制

package com.qcy.testThreadFinish;  import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future;   public class Case4 {     public static void main(String[] args) throws ExecutionException, InterruptedException {          ExecutorService pool = Executors.newFixedThreadPool(3);          Future<Integer> task1 = pool.submit(() -> {             try {                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return 2;         });          Future<Integer> task2 = pool.submit(() -> {             try {                 Thread.sleep(2000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return 3;         });          //不再接受新的任务         pool.shutdown();                  //get方法为阻塞获取         System.out.println("task1的运行结果:" + task1.get());         System.out.println("task2的运行结果:" + task2.get());          System.out.println("主线程结束");     } }

Future机制，可以参考我的另外一篇博客谈谈Future、Callable、FutureTask关系

使用CountDownLatch

package com.qcy.testThreadFinish;  import java.util.concurrent.CountDownLatch;   public class Case5 {     public static void main(String[] args) throws InterruptedException {          CountDownLatch latch = new CountDownLatch(2);          Thread t1 = new Thread(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             } finally {                 latch.countDown();             }         });         t1.start();          Thread t2 = new Thread(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             } finally {                 latch.countDown();             }         });         t2.start();          latch.await();         System.out.println("主线程结束");     } }

每调用一次countDown方法，计数器会减1，在计数器减为0之前，await方法将会阻塞主线程。有关CountDownLatch的底层原理，可以参考我的另外一篇博客CountDownLatch实现原理

使用CompletableFuture

package com.qcy.testThreadFinish;  import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException;   public class Case6 {     public static void main(String[] args) throws InterruptedException, ExecutionException {          CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return 2;         });          CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {             try {                 Thread.sleep(3000);             } catch (InterruptedException e) {                 e.printStackTrace();             }             return 3;         }).thenCombine(cf1, (result1, result2) -> result1 * result2);          //get方法为阻塞获取         System.out.println("计算结果为" + cf.get());         System.out.println("主线程结束");     } }

等到两个子任务都完成后，输出两数之积，再执行主线程。

到此，相信大家对“如何让主线程等待所有的子线程结束之后再执行”有了更深的了解，不妨来实际操作一番吧！这里是编程网网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！