Java多线程--让主线程等待所有⼦线程执⾏完毕在执⾏
朋友让我帮忙写个程序从⽂本⽂档中导⼊数据到oracle数据库中，技术上没有什么难度,⽂档的格式都是固定的只要对应数据库中的字段解析就⾏了，关键在于性能。
数据量很⼤百万条记录，因此考虑到要⽤多线程并发执⾏，在写的过程中⼜遇到问题，我想统计所有⼦进程执⾏完毕总共的耗时，在第⼀个⼦进程创建前记录当前时间⽤System.currentTimeMillis()在最后⼀个⼦进程结束后记录当前时间，两次⼀减得到的时间差即为总共的⽤时，代码如下
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(){
java重载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){
}
}
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++) {//开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){
}
public synchronized void countDown(){
count--;
}
public synchronized boolean hasNext(){
return (count > 0);
}
public int getCount() {
return count;
}
public void setCount(int 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() + "开始...");//打印开始标记
//Do something
System.out.println(Thread.currentThread().getName() + "结束. 还有" + c.getCount() + " 个线程");//打印结束标记
}
}
主线程中
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结束.
更简单的⽅法：使⽤urrent.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() + "开始...");
//Do somethings
System.out.println(Thread.currentThread().getName() + "结束. 还有" + Count() + " 个线程");
}
}
主线程中
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结束.
以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
发表评论