Java主线程等待子线程、线程池运行完成

本文转自http://blog.csdn.net/xiao__gui/article/details/9213413

 

Java主线程等待子线程、线程池

 

线程池主线程子线程CountDownLatchExecutorService

[java] view plaincopy

 

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、主线程等待一个子线程

[java] view plaincopy

 

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

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

子线程执行时长：0
Thread-0子线程开始
Thread-0子线程结束

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

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

[java] view plaincopy

 

1. public class Main  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.         long start = System.currentTimeMillis();  
6.           
7.         Thread thread = new TestThread();  
8.         thread.start();  
9.           
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. }  

执行结果：

Thread-0子线程开始
Thread-0子线程结束
子线程执行时长：5000

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

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

比如主线程需要等待5个子线程。这5个线程之间是并发执行。

[java] view plaincopy

 

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

在上面的代码套上一个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()方法。

[java] view plaincopy

 

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

执行结果：

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：

 

[java] view plaincopy

 

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

修改main：

 

 

[java] view plaincopy

 

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

执行结果：

 

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。

 

[java] view plaincopy

 

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来实现主线程等待线程池。

 

[java] view plaincopy

 

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

执行结果：

 

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更好，它有一个超时时间可以控制每隔多久循环一次，而不是一直在循环来消耗性能。

 

作者：叉叉哥   转载请注明出处：http://blog.csdn.net/xiao__gui/article/details/9213413