Java多线程--让主线程等待所有子线程执行完毕

数据量很大百万条记录,因此考虑到要用多线程并发执行,在写的过程中又遇到问题,我想统计所有子进程执行完毕总共的耗时,在第一个子进程创建前记录当前时间用System.currentTimeMillis()在最后一个子进程结束后记录当前时间,两次一减得到的时间差即为总共的用时,代码如下

Java代码  

  1. long tStart = System.currentTimeMillis();
  2. System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
  3. for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
  4. Runnable r = new Runnable(){
  5. @Override
  6. public void run(){
  7. System.out.println(Thread.currentThread().getName() + "开始");
  8. //做一些事情... ...
  9. System.out.println(Thread.currentThread().getName() + "结束.");
  10. }
  11. }
  12. Thread t = new Thread(r);
  13. t.start();
  14. }
  15. System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
  16. long tEnd = System.currentTimeMillis();
  17. System.out.println("总共用时:"+ (tEnd - tStart) + "millions");

结果是几乎在for循环结束的瞬间就执行了主线程打印总共用时的语句,原因是所有的子线程是并发执行的,它们运行时主线程也在运行,这就引出了一个问题即本文标题如何"让主线程等待所有子线程执行完毕"。试过在每个子线程开始后加上t.join(),结果是所有线程都顺序执行,这就失去了并发的意义了,显然不是我想要的。 
    网上Google了很久也没有找到解决方案,难道就没有人遇到过这种需求吗?还是这个问题太简单了?无耐只得自己想办法了... 
    最后我的解决办法是,自定义一个ImportThread类继承自java.lang.Thread,重载run()方法,用一个List属性保存所有产生的线程,这样只要判断这个List是否为空就知道还有没有子线程没有执行完了,类代码如下:

Java代码  

  1. public class ImportThread extends Thread {
  2. private static List<Thread> runningThreads = new ArrayList<Thread>();
  3. public ImportThread() {
  4. }
  5. @Override
  6. public void run() {
  7. regist(this);//线程开始时注册
  8. System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记
  9. //做一些事情... ...
  10. unRegist(this);//线程结束时取消注册
  11. System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
  12. }
  13. public void regist(Thread t){
  14. synchronized(runningThreads){
  15. runningThreads.add(t);
  16. }
  17. }
  18. public void unRegist(Thread t){
  19. synchronized(runningThreads){
  20. runningThreads.remove(t);
  21. }
  22. }
  23. public static boolean hasThreadRunning() {
  24. return (runningThreads.size() > 0);//通过判断runningThreads是否为空就能知道是否还有线程未执行完
  25. }
  26. }

主线程中代码:

Java代码  

  1. long tStart = System.currentTimeMillis();
  2. System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
  3. for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
  4. Thread t = new ImportThread();
  5. t.start();
  6. }
  7. while(true){//等待所有子线程执行完
  8. if(!ImportThread.hasThreadRunning()){
  9. break;
  10. }
  11. Thread.sleep(500);
  12. }
  13. System.out.println(Thread.currentThread().getName() + "结束.");//打印结束标记
  14. long tEnd = System.currentTimeMillis();
  15. 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类

Java代码  

  1. public class MyCountDown {
  2. private int count;
  3. public MyCountDown(int count){
  4. this.count = count;
  5. }
  6. public synchronized void countDown(){
  7. count--;
  8. }
  9. public synchronized boolean hasNext(){
  10. return (count > 0);
  11. }
  12. public int getCount() {
  13. return count;
  14. }
  15. public void setCount(int count) {
  16. this.count = count;
  17. }
  18. }

ImportThread类

Java代码  

  1. public class ImportThread extends Thread {
  2. private MyCountDown c;
  3. public ImportThread(MyCountDown c) {
  4. this.c = c;
  5. }
  6. @Override
  7. public void run() {
  8. System.out.println(Thread.currentThread().getName() + "开始...");//打印开始标记
  9. //Do something
  10. c.countDown();//计时器减1
  11. System.out.println(Thread.currentThread().getName() + "结束. 还有" + c.getCount() + " 个线程");//打印结束标记
  12. }
  13. }

主线程中

Java代码  

  1. System.out.println(Thread.currentThread().getName() + "开始");//打印开始标记
  2. MyCountDown c = new MyCountDown(threadNum);//初始化countDown
  3. for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
  4. Thread t = new ImportThread(c);
  5. t.start();
  6. }
  7. while(true){//等待所有子线程执行完
  8. if(!c.hasNext()) break;
  9. }
  10. 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类

Java代码  

  1. public class ImportThread extends Thread {
  2. private CountDownLatch threadsSignal;
  3. public ImportThread(CountDownLatch threadsSignal) {
  4. this.threadsSignal = threadsSignal;
  5. }
  6. @Override
  7. public void run() {
  8. System.out.println(Thread.currentThread().getName() + "开始...");
  9. //Do somethings
  10. threadsSignal.countDown();//线程结束时计数器减1
  11. System.out.println(Thread.currentThread().getName() + "结束. 还有" + threadsSignal.getCount() + " 个线程");
  12. }
  13. }

主线程中

Java代码  

  1. CountDownLatch threadSignal = new CountDownLatch(threadNum);//初始化countDown
  2. for (int ii = 0; ii < threadNum; ii++) {//开threadNum个线程
  3. final Iterator<String> itt = it.get(ii);
  4. Thread t = new ImportThread(itt,sql,threadSignal);
  5. t.start();
  6. }
  7. threadSignal.await();//等待所有子线程执行完
  8. 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结束.

时间: 2024-10-12 19:07:24

Java多线程--让主线程等待所有子线程执行完毕的相关文章

Java多线程、主线程等待所有子线程执行完毕、共享资源

1.Java创建与启动线程 Java提供两种方式创建和启动线程:1.直接Thread类,2.实现Runable接口. 1.1  继承Thread类 public class myThread extends Thread { public void run(){ for(int i=0;i<5;i++){ System.out.println(this.getName()+":"+i); } } public static void main(String[] args){ //

Java多线程--让主线程等待所有子线程执行完毕 join

首先从公司一道笔试题开始 1 package test; 2 3 public class Test implements Runnable { 4 5 public int i = 0; 6 7 @Override 8 public void run() { 9 try { 10 Thread.sleep(1000); 11 } catch (InterruptedException e) { 12 // TODO Auto-generated catch block 13 e.printSt

java主线程等待所有子线程执行完毕在执行(常见面试题)

java主线程等待所有子线程执行完毕在执行(常见面试题) java主线程等待所有子线程执行完毕在执行,这个需求其实我们在工作中经常会用到,比如用户下单一个产品,后台会做一系列的处理,为了提高效率,每个处理都可以用一个线程来执行,所有处理完成了之后才会返回给用户下单成功,下面就说一下我能想到的方法,欢迎大家批评指正: 用sleep方法,让主线程睡眠一段时间,当然这个睡眠时间是主观的时间,是我们自己定的,这个方法不推荐,但是在这里还是写一下,毕竟是解决方法 2.使用Thread的join()等待所有

Java主线程等待所有子线程执行完毕再执行解决办法集

Java主线程等待所有子线程执行完毕在执行,其实在我们的工作中经常的用到,比如说主线程要返回一个响应用户的值,但这个值得赋值过程是由过个子线程来完成的(模拟一个实际开发的情景),所以主线程必须等待子线程执行完毕,再响应用户:否则,响应用户的是一个无意义的值. 那么如何确保所有的子线程执行完毕了.一般的有如下方法: 1  让主线程等待,或着睡眠几分钟.用Thread.sleep()或者TimeUnit.SECONDS.sleep(5); 如下: package andy.thread.tradit

多线程同步-主线程等待所有子线程完成案例

有时候我们会遇到这样的问题:做一个大的事情可以被分解为做一系列相似的小的事情,而小的事情无非就是参数上有可能不相同而已! 此时,如果不使用线程,我们势必会浪费非常多的时间来完成整个大的事情,而使用线程的话将会存在这样的问题: 主线程启动所有子线程并发执行后主线程就直接返回了,导致外部函数判读整个大的事情完成了,但是实际上并没有完成! 针对以上情况我想我会采用多线程方式执行同时解决主线程等待子线程的问题.如图: 在这里我使用Java进行案例分析. 首先建立一个线程管理类,用于启动所有子线程和等待所

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

问题背景: 目前需要解析十多个Excel文件并将数据导入到数据库,文件导出完成之后还有后续步骤需要处理,例如更新批次状态. 如果采用单线程的方式顺序去处理每个文件的话,感觉有点慢,虽说不算是特别慢,但是由于用户需要等待导入结果, 考虑到用于体验问题,因此需要坐下性能优化.既然是性能优化,基本都是考虑到使用多线程并发处理.但是多线线程有个问题, 就是启动多个线程后,如何让当前线程等待这些子线程执行完毕,因为需要根据所以子线程的执行结果来更新批次状态 解决方案1: 基本思路是这样: 每个SubThr

c#等待所有子线程执行完毕方法

原文:c#等待所有子线程执行完毕方法 当我们在使用线程中,你会发现主线结束后子线程的结果才显示出来.现在我要等待所以子线程结束,然后在显示结果,怎么做呢? 方法如下: 1.使用 ManualResetEvent,代码如下:  using System.Threading; namespace ThreadStudy{    /// <summary>    /// 等待所有子线程结束    /// </summary>    class StopAllWaitBySubThread

[Java][Android] 多线程同步-主线程等待全部子线程完毕案例

有时候我们会遇到这种问题:做一个大的事情能够被分解为做一系列相似的小的事情,而小的事情无非就是參数上有可能不同样而已! 此时,假设不使用线程,我们势必会浪费许多的时间来完毕整个大的事情.而使用线程的话将会存在这种问题: 主线程启动全部子线程并发运行后主线程就直接返回了,导致外部函数判读整个大的事情完毕了,可是实际上并没有完毕! 针对以上情况我想我会採用多线程方式运行同一时候解决主线程等待子线程的问题.如图: watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQ

Java多线程--让主线程等待子线程执行完毕

使用Java多线程编程时经常遇到主线程需要等待子线程执行完成以后才能继续执行,那么接下来介绍一种简单的方式使主线程等待. java.util.concurrent.CountDownLatch 使用countDownLatch.await()方法非常简单的完成主线程的等待: public class ThreadWait { public static void main(String[] args) throws InterruptedException { int threadNumber