JAVA主线程与子线程操作

Java代码  

1. public class ImportThread extends Thread {  
2. private static List runningThreads = new ArrayList();  
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 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结束.