主线程等待所有子线程执行完成之后，再继续往下执行的解决方案

1. public class TestThread extends Thread
2. {
3. public void run()
4. {
5. System.out.println(this.getName() + "子线程开始");
6. try
7. {
8. // 子线程休眠五秒
9. Thread.sleep(5000);
10. }
11. catch (InterruptedException e)
12. {
13. e.printStackTrace();
14. }
15. System.out.println(this.getName() + "子线程结束");
16. }
17. }

首先是一个线程，它执行完成需要5秒。

1、主线程等待一个子线程

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. Thread thread = new TestThread();
7. thread.start();
8. long end = System.currentTimeMillis();
9. System.out.println("子线程执行时长：" + (end - start));
10. }
11. }

在主线程中，需要等待子线程执行完成。但是执行上面的main发现并不是想要的结果：

子线程执行时长：0

Thread-0子线程开始

Thread-0子线程结束

很明显主线程和子线程是并发执行的，主线程并没有等待。

对于只有一个子线程，如果主线程需要等待子线程执行完成，再继续向下执行，可以使用Thread的join()方法

join()方法会阻塞主线程继续向下执行

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. Thread thread = new TestThread();
7. thread.start();
8. try
9. {
10. thread.join();
11. }
12. catch (InterruptedException e)
13. {
14. e.printStackTrace();
15. }
16. long end = System.currentTimeMillis();
17. System.out.println("子线程执行时长：" + (end - start));
18. }
19. }

执行结果：

Thread-0子线程开始

Thread-0子线程结束

子线程执行时长：5000

注意：join()要在start()方法之后调用。

2、主线程等待多个子线程

比如主线程需要等待5个子线程

这5个线程之间是并发执行

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. for(int i = 0; i < 5; i++)
7. {
8. Thread thread = new TestThread();
9. thread.start();
10. try
11. {
12. thread.join();
13. }
14. catch (InterruptedException e)
15. {
16. e.printStackTrace();
17. }
18. }
19. long end = System.currentTimeMillis();
20. System.out.println("子线程执行时长：" + (end - start));
21. }
22. }

在上面的代码套上一个for循环，执行结果：

Thread-0子线程开始

Thread-0子线程结束

Thread-1子线程开始

Thread-1子线程结束

Thread-2子线程开始

Thread-2子线程结束

Thread-3子线程开始

Thread-3子线程结束

Thread-4子线程开始

Thread-4子线程结束

子线程执行时长：25000

由于thread.join()阻塞了主线程继续执行，导致for循环一次就需要等待一个子线程执行完成，而下一个子线程不能立即start()，5个子线程不能并发。

要想子线程之间能并发执行，那么需要在所有子线程start()后，在执行所有子线程的join()方法。

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. List<Thread> list = new ArrayList<Thread>();
7. for(int i = 0; i < 5; i++)
8. {
9. Thread thread = new TestThread();
10. thread.start();
11. list.add(thread);
12. }
13. try
14. {
15. for(Thread thread : list)
16. {
17. thread.join();
18. }
19. }
20. catch (InterruptedException e)
21. {
22. e.printStackTrace();
23. }
24. long end = System.currentTimeMillis();
25. System.out.println("子线程执行时长：" + (end - start));
26. }
27. }

执行结果：

Thread-0子线程开始

Thread-3子线程开始

Thread-1子线程开始

Thread-2子线程开始

Thread-4子线程开始

Thread-3子线程结束

Thread-0子线程结束

Thread-2子线程结束

Thread-1子线程结束

Thread-4子线程结束

子线程执行时长：5000

3、主线程等待多个子线程（CountDownLatch实现）

CountDownLatch是Java.util.concurrent中的一个同步辅助类，可以把它看做一个倒数计数器，就像神舟十号发射时倒数：10,9,8,7….2,1,0,走你。初始化时先设置一个倒数计数初始值，每调用一次countDown()方法，倒数值减一，await()方法会阻塞当前进程，直到倒数至0。

同样还是主线程等待5个并发的子线程。修改上面的代码，在主线程中，创建一个初始值为5的CountDownLatch，并传给每个子线程，在每个子线程最后调用countDown()方法对倒数器减1，当5个子线程等执行完成，那么CountDownLatch也就倒数完成，主线程调用await()方法等待5个子线程执行完成。

修改MyThread接收传入的CountDownLatch：

1. public class TestThread extends Thread
2. {
3. private CountDownLatch countDownLatch;
4. public TestThread(CountDownLatch countDownLatch)
5. {
6. this.countDownLatch = countDownLatch;
7. }
8. public void run()
9. {
10. System.out.println(this.getName() + "子线程开始");
11. try
12. {
13. // 子线程休眠五秒
14. Thread.sleep(5000);
15. }
16. catch (InterruptedException e)
17. {
18. e.printStackTrace();
19. }
20. System.out.println(this.getName() + "子线程结束");
21. // 倒数器减1
22. countDownLatch.countDown();
23. }
24. }

修改main：

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. // 创建一个初始值为5的倒数计数器
7. CountDownLatch countDownLatch = new CountDownLatch(5);
8. for(int i = 0; i < 5; i++)
9. {
10. Thread thread = new TestThread(countDownLatch);
11. thread.start();
12. }
13. try
14. {
15. // 阻塞当前线程，直到倒数计数器倒数到0
16. countDownLatch.await();
17. }
18. catch (InterruptedException e)
19. {
20. e.printStackTrace();
21. }
22. long end = System.currentTimeMillis();
23. System.out.println("子线程执行时长：" + (end - start));
24. }
25. }

执行结果：

Thread-0子线程开始

Thread-2子线程开始

Thread-1子线程开始

Thread-3子线程开始

Thread-4子线程开始

Thread-2子线程结束

Thread-4子线程结束

Thread-1子线程结束

Thread-0子线程结束

Thread-3子线程结束

子线程执行时长：5000

注意：如果子线程中会有异常，那么countDownLatch.countDown()应该写在finally里面，这样才能保证异常后也能对计数器减1，不会让主线程永远等待。

另外，await()方法还有一个实用的重载方法：public booleanawait(long timeout, TimeUnit unit)，设置超时时间。

例如上面的代码，想要设置超时时间10秒，到了10秒无论是否倒数完成到0，都会不再阻塞主线程。返回值是boolean类型，如果是超时返回false，如果计数到达0没有超时返回true。

1. // 设置超时时间为10秒
2. boolean timeoutFlag = countDownLatch.await(10,TimeUnit.SECONDS);
3. if(timeoutFlag)
4. {
5. System.out.println("所有子线程执行完成");
6. }
7. else
8. {
9. System.out.println("超时");
10. }

4、主线程等待线程池

Java线程池java.util.concurrent.ExecutorService是很好用的多线程管理方式。ExecutorService的一个方法boolean awaitTermination(long timeout, TimeUnit unit)，即阻塞主线程，等待线程池的所有线程执行完成，用法和上面所说的CountDownLatch的public boolean await(long timeout,TimeUnit unit)类似，参数设置一个超时时间，返回值是boolean类型，如果超时返回false，如果线程池中的线程全部执行完成，返回true。

由于ExecutorService没有类似CountDownLatch的无参数的await()方法，只能通过awaitTermination来实现主线程等待线程池。

1. public class Main
2. {
3. public static void main(String[] args)
4. {
5. long start = System.currentTimeMillis();
6. // 创建一个同时允许两个线程并发执行的线程池
7. ExecutorService executor = Executors.newFixedThreadPool(2);
8. for(int i = 0; i < 5; i++)
9. {
10. Thread thread = new TestThread();
11. executor.execute(thread);
12. }
13. executor.shutdown();
14. try
15. {
16. // awaitTermination返回false即超时会继续循环，返回true即线程池中的线程执行完成主线程跳出循环往下执行，每隔10秒循环一次
17. while (!executor.awaitTermination(10, TimeUnit.SECONDS));
18. }
19. catch (InterruptedException e)
20. {
21. e.printStackTrace();
22. }
23. long end = System.currentTimeMillis();
24. System.out.println("子线程执行时长：" + (end - start));
25. }
26. }

执行结果：

Thread-0子线程开始

Thread-1子线程开始

Thread-0子线程结束

Thread-2子线程开始

Thread-1子线程结束

Thread-3子线程开始

Thread-2子线程结束

Thread-4子线程开始

Thread-3子线程结束

Thread-4子线程结束

子线程执行时长：15000

另外，while(!executor.isTerminated())也可以替代上面的while (!executor.awaitTermination(10,TimeUnit.SECONDS))，isTerminated()是用来判断线程池是否执行完成。但是二者比较我认为还是awaitTermination更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

5.其它方案参考：

解决方案1：

基本思路是这样：

每个SubThread子线程类实例有个自己的状态99-初始化 0-执行成功 1-执行失败，当执行完毕之后，将状态修改为0或者1

MainThread主线程类中有个List，用来登记所有子线程。子线程的创建通过主线程来创建，每次创建之后，都会将子线程添加到List中。

所有子线程创建完成之后，通过主线程的start方法启动所有子线程，并通过一个while循环来遍历List中的所有子线程的状态，

判断是否存在状态为99的，如果没有，则便是全部子线程执行完毕

1. /**
2. * 子线程类
3. * @author Administrator
4. *
5. */
6. public class SubThread implements Runnable{
7. private int status = 99; //99-初始化 0-执行成功 1-执行失败
8. public void run() {
9. System.out.println("开始执行...");
10. try{
11. Thread.sleep(2000);
12. }catch(Exception e){
13. e.printStackTrace();
14. }
15. status=0;
16. System.out.println("执行完毕...");
17. }
18. public int getStatus() {
19. return status;
20. }
21. public void setStatus(int status) {
22. this.status = status;
23. }
24. }
25. /**
26. * 主线程类
27. * @author Administrator
28. *
29. */
30. public class MainThread {
31. private List<SubThread> subThreadList = new ArrayList<SubThread>();
32. /**
33. * 创建子线程
34. * @return
35. */
36. public SubThread createSubThread(){
37. SubThread subThread = new SubThread();
38. subThreadList.add(new SubThread());
39. return subThread;
40. }
41. public boolean start(){
42. for(SubThread subThread : subThreadList){
43. new Thread(subThread).start();
44. }
45. /**
46. * 监控所有子线程是否执行完毕
47. */
48. boolean continueFlag = true;
49. while(continueFlag){
50. for(SubThread subThread : subThreadList){
51. if(subThread.getStatus()==99){
52. continueFlag = true;
53. break;
54. }
55. continueFlag = false;
56. }
57. }
58. /**
59. * 判断子线程的执行结果
60. */
61. boolean result = true;
62. for(SubThread subThread : subThreadList){
63. if(subThread.getStatus()!=0){
64. result = false;
65. break;
66. }
67. }
68. return result;
69. }
70. }

测试代码：

1. public static void main(String[] args) {
2. MainThread main = new MainThread();
3. main.createSubThread();
4. main.createSubThread();
5. main.createSubThread();
6. boolean result = main.start();
7. System.out.println(result);
8. }

解决方案2：

通过计数器方式解决。基本思路如下：

计数器类CountLauncher负责记录正在执行的子线程的总数，所有的子线程共享该计数器类对象，当子线程执行完毕之后，调用计数器的counDown()方法进行计数器减1.

主线程通过计数器类来判断是否所有子线程都执行完毕。

1. /**
2. * 计数器类
3. * @author Administrator
4. *
5. */
6. public class CountLauncher {
7. private int count;
8. public CountLauncher(int count){
9. this.count = count;
10. }
11. public synchronized void countDown(){
12. count --;
13. }
14. public int getCount() {
15. return count;
16. }
17. public void setCount(int count) {
18. this.count = count;
19. }
20. }
21. /**
22. * 子线程类
23. * @author Administrator
24. *
25. */
26. public class SubThread implements Runnable{
27. /**
28. * 计数器类对象实例
29. */
30. private CountLauncher countLauncher;
31. private int status = 99; //99-初始化 0-执行成功 1-执行失败
32. public void run() {
33. System.out.println("开始执行...");
34. try{
35. Thread.sleep(2000);
36. }catch(Exception e){
37. e.printStackTrace();
38. }
39. status=0;
40. System.out.println("执行完毕...");
41. countLauncher.countDown();
42. }
43. public int getStatus() {
44. return status;
45. }
46. public void setStatus(int status) {
47. this.status = status;
48. }
49. public CountLauncher getCountLauncher() {
50. return countLauncher;
51. }
52. public void setCountLauncher(CountLauncher countLauncher) {
53. this.countLauncher = countLauncher;
54. }
55. }
56. /**
57. * 主线程类
58. * @author Administrator
59. *
60. */
61. public class MainThread {
62. private List<SubThread> subThreadList = new ArrayList<SubThread>();
63. /**
64. * 创建子线程
65. * @return
66. */
67. public synchronized SubThread createSubThread(){
68. SubThread subThread = new SubThread();
69. subThreadList.add(new SubThread());
70. return subThread;
71. }
72. public boolean start(){
73. CountLauncher countLauncher = new CountLauncher(subThreadList.size());
74. for(SubThread subThread : subThreadList){
75. subThread.setCountLauncher(countLauncher);
76. new Thread(subThread).start();
77. }
78. while(countLauncher.getCount()>0){
79. System.out.println(countLauncher.getCount());
80. }
81. /**
82. * 判断子线程的执行结果
83. */
84. boolean result = true;
85. for(SubThread subThread : subThreadList){
86. if(subThread.getStatus()!=0){
87. result = false;
88. break;
89. }
90. }
91. return result;
92. }
93. /**
94. * 测试实例
95. */
96. public static void main(String[] args) {
97. MainThread main = new MainThread();
98. main.createSubThread();
99. main.createSubThread();
100. main.createSubThread();
101. boolean result = main.start();
102. System.out.println(result);
103. }
104. }

六.总结

解决方案（推荐）：

使用的是Java自带的计数器类java.util.concurrent.CountDownLatch。

还有一点就是不需要在主线程中通过while来监控所有子线程，是否通过调用它的await方法进行等待所有子线程的执行完毕。

使用计数器时，需要注意的一点是：子线程中调用countDown()方法时一定要放在最后来执行，否则会出现子线程未执行完毕，主线程就开始往下执行了。因为一定计数器为0，就会自动唤醒主线程的。

文章最后喜欢的小伙伴可以关注下我的或者关注我的专栏，以后给大家带来更多精彩的技术和面试知识点分享

程序员学习之路​zhuanlan.zhihu.com