统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在最后一个子进程结束后记
录当前时间,两次一减得到的时间差即为总共的用时,代码如下
-
long
tStart = System.currentTimeMillis();
-
System.out.println(Thread.currentThread().getName() + "开始"
);
-
for
(
int
ii =
0
; ii < threadNum; ii++) {
-
Runnable r = new
Runnable(){
-
@Override
-
public
void
run(){
-
System.out.println(Thread.currentThread().getName() + "开始"
);
-
-
System.out.println(Thread.currentThread().getName() + "结束."
);
-
}
-
}
-
Thread t = new
Thread(r);
-
t.start();
-
}
-
System.out.println(Thread.currentThread().getName() + "结束."
);
-
long
tEnd = System.currentTimeMillis();
-
System.out.println("总共用时:"
+ (tEnd - tStart) +
"millions"
);
long tStart = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
Runnable r = new Runnable(){
@Override
public void run(){
System.out.println(Thread.currentThread().getName() + "开始");
//做一些事情... ...
System.out.println(Thread.currentThread().getName() + "结束.");
}
}
Thread t = new Thread(r);
t.start();
}
System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
long tEnd = System.currentTimeMillis();
System.out.println("总共用时:"+ (tEnd - tStart) + "millions");
结果是几乎在for循环结束的瞬间就执行了主线程打印总共用时的语句,原因是所有的子线程是并发执行的,它们运行时主线程也在运行,这就引出了一个问题即
本文标题如何"让主线程等待所有子线程执行完毕"。试过在每个子线程开始后加上t.join(),结果是所有线程都顺序执行,这就失去了并发的意义了,显
然不是我想要的。
网上Google了很久也没有找到解决方案,难道就没有人遇到过这种需求吗?还是这个问题太简单了?无耐只得自己想办法了...
最后我的解决办法
是,自定义一个ImportThread类继承自
java.lang.Thread,重载run()方法,用一个List属性保存所有产生的线程,这样只要判断这个List是否为空就知道还有没有子线程
没有执行完了,类代码如下：
-
public
class
ImportThread
extends
Thread {
-
private
static
List<Thread> runningThreads =
new
ArrayList<Thread>();
-
public
ImportThread() {
-
}
-
@Override
-
public
void
run() {
-
regist(this
);
-
System.out.println(Thread.currentThread().getName() + "开始..."
);
-
-
unRegist(this
);
-
System.out.println(Thread.currentThread().getName() + "结束."
);
-
}
-
public
void
regist(Thread t){
-
synchronized
(runningThreads){
-
runningThreads.add(t);
-
}
-
}
-
public
void
unRegist(Thread t){
-
synchronized
(runningThreads){
-
runningThreads.remove(t);
-
}
-
}
-
public
static
boolean
hasThreadRunning() {
-
return
(runningThreads.size() >
0
);
-
}
-
}
public class ImportThread extends Thread {
private static List<Thread> runningThreads = new ArrayList<Thread>();
public ImportThread() {
}
@Override
public void run() {
regist(this);//线程开始时注册
System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记
//做一些事情... ...
unRegist(this);//线程结束时取消注册
System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
}
public void regist(Thread t){
synchronized(runningThreads){
runningThreads.add(t);
}
}
public void unRegist(Thread t){
synchronized(runningThreads){
runningThreads.remove(t);
}
}
public static boolean hasThreadRunning() {
return (runningThreads.size() > 0);//通过判断runningThreads是否为空就能知道是否还有线程未执行完
}
}
主线程中代码：
-
long
tStart = System.currentTimeMillis();
-
System.out.println(Thread.currentThread().getName() + "开始"
);
-
for
(
int
ii =
0
; ii < threadNum; ii++) {
-
Thread t = new
ImportThread();
-
t.start();
-
}
-
while
(
true
){
-
if
(!ImportThread.hasThreadRunning()){
-
break
;
-
}
-
Thread.sleep(500
);
-
}
-
System.out.println(Thread.currentThread().getName() + "结束."
);
-
long
tEnd = System.currentTimeMillis();
-
System.out.println("总共用时:"
+ (tEnd - tStart) +
"millions"
);
long tStart = System.currentTimeMillis();
System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
Thread t = new ImportThread();
t.start();
}
while(true){//等待所有子线程执行完
if(!ImportThread.hasThreadRunning()){
break;
}
Thread.sleep(500);
}
System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
long tEnd = System.currentTimeMillis();
System.out.println("总共用时:"+ (tEnd - tStart) + "millions");
打印的结果是：
main开始
Thread-1开始...
Thread-5开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5结束.
Thread-4结束.
Thread-2结束.
Thread-0结束.
Thread-3结束.
Thread-1结束.
main结束.
总共用时:20860millions
可以看到main线程是等所有子线程全部执行完后才开始执行的。
==================================================以下为第二次编
辑===============================================
上面的方法有一个隐患
:如果线程1开始并且结束了,而其他线程还没有开始此时
runningThreads的size也为0,主线程会以为所有线程都执行完了。解决办法是用一个非简单类型的计数器来取代List型的
runningThreads,并且在线程创建之前就应该设定好计数器的值。
MyCountDown类
-
public
class
MyCountDown {
-
private
int
count;
-
public
MyCountDown(
int
count){
-
this
.count = count;
-
}
-
public
synchronized
void
countDown(){
-
count--;
-
}
-
public
synchronized
boolean
hasNext(){
-
return
(count >
0
);
-
}
-
public
int
getCount() {
-
return
count;
-
}
-
public
void
setCount(
int
count) {
-
this
.count = count;
-
}
-
}
public class MyCountDown {
private int count;
public MyCountDown(int count){
this.count = count;
}
public synchronized void countDown(){
count--;
}
public synchronized boolean hasNext(){
return (count > 0);
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
ImportThread类
-
public
class
ImportThread
extends
Thread {
-
private
MyCountDown c;
-
public
ImportThread(MyCountDown c) {
-
this
.c = c;
-
}
-
@Override
-
public
void
run() {
-
System.out.println(Thread.currentThread().getName() + "开始..."
);
-
-
c.countDown();
-
System.out.println(Thread.currentThread().getName() + "结束. 还有"
+ c.getCount() +
" 个线程"
);
-
}
-
}
public class ImportThread extends Thread {
private MyCountDown c;
public ImportThread(MyCountDown c) {
this.c = c;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记
//Do something
c.countDown();//计时器减1
System.out.println(Thread.currentThread().getName() + "结束. 还有" + c.getCount() + " 个线程");//打印结束标记
}
}
主线程中
-
System.out.println(Thread.currentThread().getName() +
"开始"
);
-
MyCountDown c = new
MyCountDown(threadNum);
-
for
(
int
ii =
0
; ii < threadNum; ii++) {
-
Thread t = new
ImportThread(c);
-
t.start();
-
}
-
while
(
true
){
-
if
(!c.hasNext())
break
;
-
}
-
System.out.println(Thread.currentThread().getName() + "结束."
);
System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
MyCountDown c = new MyCountDown(threadNum);//初始化countDown
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
Thread t = new ImportThread(c);
t.start();
}
while(true){//等待所有子线程执行完
if(!c.hasNext()) break;
}
System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
打印结果:
main开始
Thread-2开始...
Thread-1开始...
Thread-0开始...
Thread-3开始...
Thread-5开始...
Thread-4开始...
Thread-5结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-3结束. 还有1 个线程
Thread-0结束. 还有0 个线程
main结束.
更简单的
方法:
使用java.util.concurrent.CountDownLatch代替MyCountDown,用await()方法代替
while(true){...}
ImportThread类
-
public
class
ImportThread
extends
Thread {
-
private
CountDownLatch threadsSignal;
-
public
ImportThread(CountDownLatch threadsSignal) {
-
this
.threadsSignal = threadsSignal;
-
}
-
@Override
-
public
void
run() {
-
System.out.println(Thread.currentThread().getName() + "开始..."
);
-
-
threadsSignal.countDown();
-
System.out.println(Thread.currentThread().getName() + "结束. 还有"
+ threadsSignal.getCount() +
" 个线程"
);
-
}
-
}
public class ImportThread extends Thread {
private CountDownLatch threadsSignal;
public ImportThread(CountDownLatch threadsSignal) {
this.threadsSignal = threadsSignal;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "开始...");
//Do somethings
threadsSignal.countDown();//线程结束时计数器减1
System.out.println(Thread.currentThread().getName() + "结束. 还有" + threadsSignal.getCount() + " 个线程");
}
}
主线程中
-
CountDownLatch threadSignal =
new
CountDownLatch(threadNum);
-
for
(
int
ii =
0
; ii < threadNum; ii++) {
-
final
Iterator<String> itt = it.get(ii);
-
Thread t = new
ImportThread(itt,sql,threadSignal);
-
t.start();
-
}
-
threadSignal.await();
-
System.out.println(Thread.currentThread().getName() + "结束."
);
CountDownLatch threadSignal = new CountDownLatch(threadNum);//初始化countDown
for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
final Iterator<String> itt = it.get(ii);
Thread t = new ImportThread(itt,sql,threadSignal);
t.start();
}
threadSignal.await();//等待所有子线程执行完
System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
打印结果:
main开始
Thread-1开始...
Thread-0开始...
Thread-2开始...
Thread-3开始...
Thread-4开始...
Thread-5开始...
Thread-0结束. 还有5 个线程
Thread-1结束. 还有4 个线程
Thread-4结束. 还有3 个线程
Thread-2结束. 还有2 个线程
Thread-5结束. 还有1 个线程
Thread-3结束. 还有0 个线程
main结束.
see：http://3ccoder.iteye.com/blog/581476
分享到：
相关推荐
在Java多线程编程中，有时我们需要确保所有子线程执行完毕后再进行后续操作，例如在并发测试、数据聚合或资源清理等场景。本篇文章将详细介绍五种在Java中等待所有子线程执行完的方法。 ### 方法一：使用`sleep`...
在Java多线程编程中，有时我们需要确保主线程在所有子线程完成执行后再继续执行。这在处理大量并发任务，比如数据导入、并行计算等场景中是常见的需求。以下是如何实现这一功能的详细解释。 首先，让我们理解为什么...
Java 主线程等待子线程执行完毕 Java 中的多线程编程是非常重要的一部分，特别是在需要并发执行多个任务的情况下。然而，在某些情况下，我们需要等待所有子线程执行完毕后再继续执行主线程的剩余动作。这时，我们...
要解决“让主线程等待所有子线程执行完毕”的问题，可以采用以下策略： 1. 使用`join()`方法：如提到的，直接在每个子线程的`start()`之后调用`t.join()`，会导致所有线程按顺序执行。这是因为`join()`会让主线程...
总的来说，Java提供了丰富的多线程同步机制，可以根据实际需求选择合适的方法来实现“主线程等待所有子线程完成再继续”的功能。在并发编程中，理解并灵活运用这些工具对于提高程序效率和避免死锁等问题至关重要。
在多线程编程中，有时我们需要确保主线程在所有子线程执行完毕后才继续执行。这通常是为了保证数据的一致性或者按照特定顺序完成任务。"主线程等待子多线程(无结果返回)执行完成再继续执行"这个主题就涉及到如何在...
本篇文章将深入探讨如何在Python中实现多线程，并让主线程等待所有子线程结束。 首先，我们需要了解Python中的`threading`模块，它是Python标准库中用于处理多线程的模块。在示例代码中，我们创建了两个函数`a()`和...
自己学着编写的一个JAVA多线程程序，该程序实现的功能是：在主线程main中创建两个子线程，A和B，线程A先运行，再运行B线程，当两个子线程都运行完毕后，才运行主线程，并最终结束整个程序的运行。 希望该程序对初学...
为解决这个问题，我们需要使用同步机制，如Java中的`join()`方法或C#的`Thread.Join()`，让主线程等待所有子线程完成后再继续执行。当调用`join()`方法时，主线程会被阻塞，直到被调用的线程执行完毕。 例如，在...
// 主线程等待thread1执行完毕 thread1.join(); ``` **异常处理**： 在多线程环境中，每个线程都有自己的异常处理机制。主线程不会捕获子线程抛出的异常，因此在子线程中需要妥善处理异常，避免程序意外终止。 总...
1. **主线程等待子线程完成**：在多线程环境中，主线程有时需要等待所有子线程执行完毕后才进行后续处理，如清理资源或汇总子线程的计算结果。 2. **线程间数据同步**：当一个线程依赖于另一个线程产生的数据时，...
然后调用`s.join()`，这就意味着主线程会暂停执行，直到子线程`s`执行完毕。这种行为确保了子线程的操作先于主线程的后续操作完成。 在`join()`方法的源码分析中，我们可以看到两个重载版本：一个不带参数，一个带...
线程是程序执行流的最小单元，一个标准的程序只能执行一个任务，而使用多线程技术可以让程序同时执行多个任务，从而提高程序的性能。 #### 2. 线程与进程的区别 - **进程**：每个进程都有独立的代码和数据空间（即...
当主线程结束时，所有由主线程创建的子线程也将随之结束。这是Java虚拟机（JVM）的行为，确保了程序的整洁关闭。 #### 4. 线程的终止 除了自然结束外，线程还可以通过调用`stop()`方法强制停止。然而，此方法已被...
2. **主线程等待子线程**：接着，主线程通过调用`join()`方法等待子线程执行完毕。 3. **子线程执行完毕**：子线程执行完毕后，主线程继续执行后续逻辑。 通过这种方式，我们可以清晰地控制线程之间的执行顺序。 ...
在Java多线程编程中，CountDownLatch是一个非常重要的同步工具类，它可以帮助我们协调多个线程之间的交互。本文将深入探讨CountDownLatch的工作原理、使用场景以及相关源码分析。 CountDownLatch是一个计数器，初始...
8. 调用`countDownLatch.await()`，主线程会阻塞等待直到所有子线程执行完毕。 需要注意的是，为了确保线程安全，文件读取和重命名操作应当采取措施避免冲突，例如可以在读取文件时使用文件锁机制，或是在重命名...
主线程将等待所有的子线程执行完毕，然后再继续执行。这种方式可以确保所有的子线程按照一定的顺序执行。 第三种方式：通过线程执行时Join()来实现。在这种方式中，我们使用线程的Join()方法来控制线程的执行顺序。...