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

转载 2013年12月02日 17:48:18
[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.         // 倒数器减1  
  24.         countDownLatch.countDown();  
  25.           
  26.         System.out.println(this.getName() + "子线程结束");  
  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更好,它有一个超时时间可以控制每隔多久循环一次,而不是一直在循环来消耗性能。

相关文章推荐

Java子线程和主线程交替输出(一个简单的实例)

实现主线程和子线程的交替输出打印,首先创建一个实现线程方法的Service public class Service { boolean flag = false; //这是一个控制sub和mi...

Java线程实例讲解综述

编写具有多线程能力的程序经常会用到的方法有:   run(), start(), wait(), notify(), notifyAll(), sleep(), yield(), join()...

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

public class TestThread extends Thread { public void run() { System.out.println(this.getName() +...

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

线程池主线程子线程CountDownLatchExecutorService [java] view plaincopy public class Te...

java线程池主线程等待子线程执行完成

原文:http://www.jiacheo.org/blog/262  Java如何等待子线程执行结束 今天讨论一个入门级的话题, 不然没东西更新对不起空间和域名~~ 工作总往往...
  • yaowj2
  • yaowj2
  • 2012年04月06日 11:07
  • 19658

主线程等待子线程结束

  • 2010年05月10日 17:13
  • 15KB
  • 下载

Java实现主线程等待子线程

本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明: 1、使用Thread的join()方法,join()方法会阻塞主线程继续向下执行。 2、使用java.util.concurrent中...
  • NMS312
  • NMS312
  • 2014年06月11日 22:10
  • 22074
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java主线程等待子线程、线程池
举报原因:
原因补充:

(最多只允许输入30个字)