面试官：如何让主线程等待所有的子线程结束之后再执行？我懵了

使用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(() -> {              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; /**  * @author qcy  * @create 2020/09/09 17:05:23  */ 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; /**  * @author qcy  * @create 2020/09/09 17:05:23  */ 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; /**  * @author qcy  * @create 2020/09/09 17:05:23  */ 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，b2b供应网等待的线在计数器减为0之前，所有束await方法将会阻塞主线程。有关CountDownLatch的底层原理，可以参考我的另外一篇博客CountDownLatch实现原理

使用CompletableFuture

package com.qcy.testThreadFinish; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; /**  * @author qcy  * @create 2020/09/09 17:05:23  */ 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("主线程结束");     } } 

等到两个子任务都完成后，输出两数之积，再执行主线程。对CompletableFuture不熟悉的同学，可以参考我的这一篇文章什么，你还不会用CompletableFuture?

很赞哦!（6）