Java 主线程等待子线程执行完再执行

来源：互联网发布：安卓lua 虚拟按键源码编辑：程序博客网时间：2024/05/21 06:44

转载原文处：http://blog.csdn.net/u011270461/article/details/14003951

http://www.cnblogs.com/jsunday/p/3782874.html

http://www.tuicool.com/articles/ZvAFny

因为最近对于线程方面的知识想进行了解，所以查阅了下这方面的知识进行整合。。。。有兴趣的可以进上面原文的地址去看看

1. Demo1 - thread.join()

[java] view plain copy
public class MyTask1 implements Runnable {  
  
    private int num ;  
    public MyTask1(int num){  
        this.num = num;  
    }  
    /* 
     * @see java.lang.Runnable#run() 
     */  
    @Override  
    public void run() {  
        for (int i = 0; i < 2; i++) {  
            System.out.println(num + "----" +i);  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println("Thread" + num + " End.");  
    }  
}  

[java] view plain copy
import java.util.ArrayList;  
import java.util.List;  
  
public class TestThreadMain1 {  
  
    /**  
     * @Title main  
     * @Description TODO 
     * @Author weizhi2018  
     * @param args         
     * @throws  
     */  
  
    public static void main(String[] args) {  
        long startTime = System.currentTimeMillis();  
        List<Thread> list = new ArrayList<Thread>();  
          
        int num = 5;  
          
        for(int i=0;i<num;i++){  
            Thread thread = new Thread(new MyTask1(i));  
            thread.start();  
            list.add(thread);  
        }  
        for(Thread thread:list){  
            try {  
                thread.join();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        long endTime = System.currentTimeMillis();  
          
        System.out.println("RunTime:"+ (endTime - startTime));  
    }  
  
}  

output:

[java] view plain copy
0----0  
4----0  
2----0  
3----0  
1----0  
1----1  
2----1  
3----1  
4----1  
0----1  
Thread2 End.  
Thread4 End.  
Thread0 End.  
Thread1 End.  
Thread3 End.  
RunTime:2017  

2. Demo2 - countDownLatch.await()

[java] view plain copy
import java.util.concurrent.CountDownLatch;  
  
public class MyTask2 implements Runnable {  
  
    private CountDownLatch countDownLatch ;  
    public MyTask2(CountDownLatch countDownLatch){  
        this.countDownLatch = countDownLatch;  
    }  
    /* 
     * @see java.lang.Runnable#run() 
     */  
    @Override  
    public void run() {  
        for (int i = 0; i < 2; i++) {  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
        System.out.println(Thread.currentThread().getName() + " End.");  
        countDownLatch.countDown();  
    }  
}  

[java] view plain copy
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.TimeUnit;  
  
public class TestThreadMain2 {  
  
    /**  
     * @Title main  
     * @Description TODO 
     * @Author weizhi2018  
     * @param args         
     * @throws  
     */  
  
    public static void main(String[] args) {  
        long startTime = System.currentTimeMillis();  
          
        int num = 5;  
          
        CountDownLatch countDownLatch = new CountDownLatch(num);    
        for(int i=0;i<num;i++){  
            Thread thread = new Thread(new MyTask2(countDownLatch));  
            thread.start();  
        }  
          
        try {  
            //等待，直到计数器为0  
            countDownLatch.await(10, TimeUnit.SECONDS);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
          
        long endTime = System.currentTimeMillis();  
          
        System.out.println("RunTime:"+ (endTime - startTime));  
    }  
  
}  

output:

[java] view plain copy
Thread-4 End.  
Thread-0 End.  
Thread-2 End.  
Thread-3 End.  
Thread-1 End.  
RunTime:2016  

3.主线程等待线程池执行完再执行

[java] view plain copy
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
public class TestThreadPoolMain {  
  
    /**  
     * @Title main  
     * @Description TODO 
     * @Author weizhi2018  
     * @param args         
     * @throws  
     */  
  
    public static void main(String[] args) {  
        long start = System.currentTimeMillis();    
          
        ExecutorService executor = Executors.newFixedThreadPool(2);    
        for(int i = 0; i < 3; i++)    
        {    
            Thread thread = new Thread(new MyTask1(i));    
            executor.execute(thread);    
        }    
        executor.shutdown();    
            
        try    
        {    
            // awaitTermination返回false即超时会继续循环，返回true即线程池中的线程执行完成主线程跳出循环往下执行，每隔10秒循环一次    
            while (!executor.awaitTermination(10, TimeUnit.SECONDS));    
        }    
        catch (InterruptedException e)    
        {    
            e.printStackTrace();    
        }    
            
        long end = System.currentTimeMillis();    
        System.out.println("RunTime:" + (end - start));    
    }  
  
}  

output:

[java] view plain copy

0----0
1----0
0----1
1----1
Thread1 End.
2----0
Thread0 End.
2----1
Thread2 End.
RunTime:4019

方法4：

1 让主线程等待，或着睡眠几分钟。用Thread.sleep()或者TimeUnit.SECONDS.sleep(5);如下：

package andy.thread.traditional.test;import java.util.concurrent.TimeUnit;/** * @author Zhang,Tianyou * @version 2014年11月21日 下午11:15:27 */public class ThreadSubMain1 {public static void main(String[] args) {// TODO Auto-generated method stubfor (int i = 0; i < 10; i++) {new Thread(new Runnable() {public void run() {try {Thread.sleep(1000);// 模拟子线程任务} catch (InterruptedException e) {}System.out.println("子线程" + Thread.currentThread() + "执行完毕");}}).start();}try {// 等待全部子线程执行完毕TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("主线执行。");}}

效果如下：

子线程Thread[Thread-1,5,main]执行完毕子线程Thread[Thread-3,5,main]执行完毕子线程Thread[Thread-5,5,main]执行完毕子线程Thread[Thread-7,5,main]执行完毕子线程Thread[Thread-9,5,main]执行完毕子线程Thread[Thread-0,5,main]执行完毕子线程Thread[Thread-2,5,main]执行完毕子线程Thread[Thread-4,5,main]执行完毕子线程Thread[Thread-6,5,main]执行完毕子线程Thread[Thread-8,5,main]执行完毕主线执行。

此方主线程只是睡了5秒，但是不能保证全部的子线程执行完成，所以这儿的5秒只是一个估值。

方法5：

FutureDemo

　　使用并发包下面的Future模式.

　　Future是一个任务执行的结果, 他是一个将来时, 即一个任务执行, 立即异步返回一个Future对象, 等到任务结束的时候, 会把值返回给这个future对象里面. 我们可以使用　　　　ExecutorService接口来提交一个线程.(注意：Future.get()为一个阻塞方法)

　　示例：

package com.test;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class FutureDemo {//创建一个容量为1的线程池static ExecutorService executorService = Executors.newFixedThreadPool(1);public static void main(String[] args) throws Exception {//创建线程并提交线程，同时获取一个future对象Thread subThread = new Thread(new SubThread());Future future = executorService.submit(subThread);//主线程处理其他工作，让子线程异步去执行mainWork();//阻塞,等待子线程结束future.get(); System.out.println("Now all thread done!");//关闭线程池executorService.shutdown();}//主线程工作private static void mainWork(){System.out.println("Main thread start work!");try {Thread.sleep(2000L);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("Main Thread work done!");}/** * 子线程类 * @author fuhg */private static class SubThread implements Runnable{public void run() {// TODO Auto-generated method stubSystem.out.println("Sub thread is starting!");try {Thread.sleep(5000L);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println("Sub thread is stopping!");}}}

1 0