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

[[391867]]

使用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，在计数器减为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?