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

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

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是否为空就知道还有没有子线程没有执行完了,类代码如下：

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. }

主线程中代码：

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类

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类

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. }

主线程中

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类

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. }

主线程中

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结束.