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

谁借莪１个温暖的怀抱￠ 2022-12-05 10:09 83阅读 0赞

## 使用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吗？][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

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

--------------------

## 使用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机制，可以参考我的另外一篇博客[谈谈Runnable、Future、Callable、FutureTask之间的关系][Runnable_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，在计数器减为0之前，await方法将会阻塞主线程。有关CountDownLatch的底层原理，可以参考我的另外一篇博客[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？][CompletableFuture]

[Thread.join]: https://blog.csdn.net/qq_33591903/article/details/108518849
[Link 1]: https://blog.csdn.net/qq_33591903/article/details/106239102
[Runnable_Future_Callable_FutureTask]: https://blog.csdn.net/qq_33591903/article/details/108422098
[CountDownLatch]: https://blog.csdn.net/qq_33591903/article/details/106135344
[CompletableFuture]: https://blog.csdn.net/qq_33591903/article/details/108421663