Java并发编程原理与实战六:主线程等待子线程解决方案
本文将研究的是主线程等待所有子线程执行完成之后再继续往下执行的解决方案
public class TestThread extends Thread
{
public void run()
{
System.out.println(this.getName() + "子线程开始");
try
{
// 子线程休眠五秒
Thread.sleep(5000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}
System.out.println(this.getName() + "子线程结束");
}
}
首先是一个线程,它执行完成需要5秒。
1、主线程等待一个子线程
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); Thread thread = new TestThread();
thread.start(); long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
在主线程中,需要等待子线程执行完成。但是执行上面的main发现并不是想要的结果:
子线程执行时长:0
Thread-0子线程开始
Thread-0子线程结束
很明显主线程和子线程是并发执行的,主线程并没有等待。
对于只有一个子线程,如果主线程需要等待子线程执行完成,再继续向下执行,可以使用Thread的join()方法。join()方法会阻塞主线程继续向下执行。
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); Thread thread = new TestThread();
thread.start(); try
{
thread.join();
}
catch (InterruptedException e)
{
e.printStackTrace();
} long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
执行结果:
Thread-0子线程开始
Thread-0子线程结束
子线程执行时长:5000
注意:join()要在start()方法之后调用。
2、主线程等待多个子线程
比如主线程需要等待5个子线程。这5个线程之间是并发执行。
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); for(int i = 0; i < 5; i++)
{
Thread thread = new TestThread();
thread.start(); try
{
thread.join();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
} long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
在上面的代码套上一个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()方法。
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); List<Thread> list = new ArrayList<Thread>();
for(int i = 0; i < 5; i++)
{
Thread thread = new TestThread();
thread.start();
list.add(thread);
} try
{
for(Thread thread : list)
{
thread.join();
}
}
catch (InterruptedException e)
{
e.printStackTrace();
} long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
执行结果:
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:
public class TestThread extends Thread
{
private CountDownLatch countDownLatch; public TestThread(CountDownLatch countDownLatch)
{
this.countDownLatch = countDownLatch;
} public void run()
{
System.out.println(this.getName() + "子线程开始");
try
{
// 子线程休眠五秒
Thread.sleep(5000);
}
catch (InterruptedException e)
{
e.printStackTrace();
} System.out.println(this.getName() + "子线程结束"); // 倒数器减1
countDownLatch.countDown();
}
}
修改main:
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); // 创建一个初始值为5的倒数计数器
CountDownLatch countDownLatch = new CountDownLatch(5);
for(int i = 0; i < 5; i++)
{
Thread thread = new TestThread(countDownLatch);
thread.start();
} try
{
// 阻塞当前线程,直到倒数计数器倒数到0
countDownLatch.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
} long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
执行结果:
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。
// 设置超时时间为10秒
boolean timeoutFlag = countDownLatch.await(10,TimeUnit.SECONDS);
if(timeoutFlag)
{
System.out.println("所有子线程执行完成");
}
else
{
System.out.println("超时");
}
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来实现主线程等待线程池。
public class Main
{
public static void main(String[] args)
{
long start = System.currentTimeMillis(); // 创建一个同时允许两个线程并发执行的线程池
ExecutorService executor = Executors.newFixedThreadPool(2);
for(int i = 0; i < 5; i++)
{
Thread thread = new TestThread();
executor.execute(thread);
}
executor.shutdown(); try
{
// awaitTermination返回false即超时会继续循环,返回true即线程池中的线程执行完成主线程跳出循环往下执行,每隔10秒循环一次
while (!executor.awaitTermination(10, TimeUnit.SECONDS));
}
catch (InterruptedException e)
{
e.printStackTrace();
} long end = System.currentTimeMillis();
System.out.println("子线程执行时长:" + (end - start));
}
}
执行结果:
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.其它方案参考:
/**
* 子线程类
* @author Administrator
*
*/
public class SubThread implements Runnable{ private int status = 99; //99-初始化 0-执行成功 1-执行失败 public void run() {
System.out.println("开始执行...");
try{
Thread.sleep(2000);
}catch(Exception e){
e.printStackTrace();
}
status=0;
System.out.println("执行完毕...");
} public int getStatus() {
return status;
} public void setStatus(int status) {
this.status = status;
}
}
/**
* 主线程类
* @author Administrator
*
*/
public class MainThread {
private List<SubThread> subThreadList = new ArrayList<SubThread>(); /**
* 创建子线程
* @return
*/
public SubThread createSubThread(){
SubThread subThread = new SubThread();
subThreadList.add(new SubThread());
return subThread;
} public boolean start(){
for(SubThread subThread : subThreadList){
new Thread(subThread).start();
} /**
* 监控所有子线程是否执行完毕
*/
boolean continueFlag = true;
while(continueFlag){
for(SubThread subThread : subThreadList){
if(subThread.getStatus()==99){
continueFlag = true;
break;
}
continueFlag = false;
}
} /**
* 判断子线程的执行结果
*/
boolean result = true;
for(SubThread subThread : subThreadList){
if(subThread.getStatus()!=0){
result = false;
break;
}
} return result;
} }
测试代码:
public static void main(String[] args) {
MainThread main = new MainThread();
main.createSubThread();
main.createSubThread();
main.createSubThread();
boolean result = main.start();
System.out.println(result);
}
/**
* 计数器类
* @author Administrator
*
*/
public class CountLauncher {
private int count; public CountLauncher(int count){
this.count = count;
} public synchronized void countDown(){
count --;
} public int getCount() {
return count;
} public void setCount(int count) {
this.count = count;
}
}
/**
* 子线程类
* @author Administrator
*
*/
public class SubThread implements Runnable{ /**
* 计数器类对象实例
*/
private CountLauncher countLauncher; private int status = 99; //99-初始化 0-执行成功 1-执行失败 public void run() {
System.out.println("开始执行...");
try{
Thread.sleep(2000);
}catch(Exception e){
e.printStackTrace();
}
status=0;
System.out.println("执行完毕...");
countLauncher.countDown();
} public int getStatus() {
return status;
} public void setStatus(int status) {
this.status = status;
} public CountLauncher getCountLauncher() {
return countLauncher;
} public void setCountLauncher(CountLauncher countLauncher) {
this.countLauncher = countLauncher;
} }
/**
* 主线程类
* @author Administrator
*
*/
public class MainThread {
private List<SubThread> subThreadList = new ArrayList<SubThread>(); /**
* 创建子线程
* @return
*/
public synchronized SubThread createSubThread(){
SubThread subThread = new SubThread();
subThreadList.add(new SubThread());
return subThread;
} public boolean start(){
CountLauncher countLauncher = new CountLauncher(subThreadList.size());
for(SubThread subThread : subThreadList){
subThread.setCountLauncher(countLauncher);
new Thread(subThread).start();
} while(countLauncher.getCount()>0){
System.out.println(countLauncher.getCount());
} /**
* 判断子线程的执行结果
*/
boolean result = true;
for(SubThread subThread : subThreadList){
if(subThread.getStatus()!=0){
result = false;
break;
}
} return result;
} /**
* 测试实例
*/
public static void main(String[] args) { MainThread main = new MainThread();
main.createSubThread();
main.createSubThread();
main.createSubThread();
boolean result = main.start();
System.out.println(result);
} }
Java并发编程原理与实战六:主线程等待子线程解决方案的更多相关文章
- Java并发编程原理与实战二十五:ThreadLocal线程局部变量的使用和原理
1.什么是ThreadLocal ThreadLocal顾名思义是线程局部变量.这种变量和普通的变量不同,这种变量在每个线程中通过get和set方法访问, 每个线程有自己独立的变量副本.线程局部变量不 ...
- Java并发编程原理与实战五:创建线程的多种方式
一.继承Thread类 public class Demo1 extends Thread { public Demo1(String name) { super(name); } @Override ...
- JAVA进阶----主线程等待子线程各种方案比较(转)
创建线程以及管理线程池基本理解 参考原文链接:http://www.oschina.net/question/12_11255?sort=time 一.创建一个简单的java线程 在 Java 语言中 ...
- java多线程实现主线程等待子线程执行完问题
本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明: 1.使用Thread的join()方法,join()方法会阻塞主线程继续向下执行. 2.使用Java.util.concurrent中的C ...
- Java实现主线程等待子线程
本文介绍两种主线程等待子线程的实现方式,以5个子线程来说明: 1.使用Thread的join()方法,join()方法会阻塞主线程继续向下执行. 2.使用Java.util.concurrent中的C ...
- Java多线程之以7种方式让主线程等待子线程结束
记一次主线程等待子线程结束的多种方法的学习 在学习多线程时,最开始遇到的问题其实是"计算子线程运行时间",写到最后发现本文和标题更为符合,但是仍然基于问题:"在主线程中获 ...
- C#主线程等待子线程运行结束
佐左佑右 原文 C#主线程等待子线程运行结束 由于主程序中调用matlab的dll文件进行计算要用较长的时间,主界面会有很长时间的卡顿,造成的用户感受十分不好,因此我想在调用时,将调用放入子线程中,然 ...
- Java主线程等待子线程、线程池
public class TestThread extends Thread { public void run() { System.out.println(this.getName() + &qu ...
- Java并发编程原理与实战三十一:Future&FutureTask 浅析
一.Futrue模式有什么用?------>正所谓技术来源与生活,这里举个栗子.在家里,我们都有煮菜的经验.(如果没有的话,你们还怎样来泡女朋友呢?你懂得).现在女票要你煮四菜一汤,这汤是鸡汤, ...
随机推荐
- [二叉树建树]1119. Pre- and Post-order Traversals (30) (前序和后序遍历建立二叉树)
1119. Pre- and Post-order Traversals (30) Suppose that all the keys in a binary tree are distinct po ...
- Sprint1回顾
Sprint目标 此产品为适用于小学生使用的四则运算训练软件.关于第一期Sprint冲刺的目标,我们打算实现产品的以下几点的功能: •1.初始界面设计 •2.四则基本运算算法 •3.能产生随机式子 • ...
- Scrum 5.0(继4.0)
一,组员任务完成情况 首页设计初步完成但是需要优化界面,只能简单的输出信息和在首页进行登录.界面极其简单. 鸡汤版面设计有困难,问题在于用何种形式来管理用户的数据上传,但是经过小组间的讨论确定设计方向 ...
- 给表格控件DBGrid加上记录序号的列
DBGrid使用起来还是很方便的,但就是没有显示记录序号的功能,必须自己加,参照老外给的解决方案如下: 方案1: 1- 在DBGrid建一个第一列 (列的名字起“NO”) 2- 在DBGrid事件 D ...
- tomcat 启动异常 EOFException: Unexpected end of ZLIB input stream
EVERE: Exception fixing docBase for context [/agdis] java.io .EOFException: Unexpected end of ZLIB i ...
- Nim游戏学习笔记
- BZOJ3243 NOI2013向量内积(随机化)
考虑奇技淫巧. 首先是k=2.对向量维护一个前缀和,每次将当前向量与前缀和点乘.如果点乘结果不等于i-1&1,说明当前向量至少和之前的某个向量的数量积是2的倍数,暴力找就可以了.当然等于i-1 ...
- HDU 6184 Counting Stars
Problem Description Little A is an astronomy lover, and he has found that the sky was so beautiful!S ...
- [BZOJ4556][Tjoi2016&Heoi2016]字符串 后缀数组+主席树
4556: [Tjoi2016&Heoi2016]字符串 Time Limit: 20 Sec Memory Limit: 128 MB Description 佳媛姐姐过生日的时候,她的小 ...
- hdu 5195 DZY Loves Topological Sorting (拓扑排序+线段树)
DZY Loves Topological Sorting Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 131072/131072 ...