JAVA主线程等待子线程执行完毕再执行

原文出处：http://wenku.baidu.com/link?url=m2znUB_1FZ3oUKOmLM22GILDUJcZu7sLNjzhN4ddF1yJr_IxceWod_wz270WUDoPVsTGca9EcIGHNB8Qi8jzd2zjNPyE22wFtsg8vXaBcaC

问题:如何实现 java 主线程等待子线程执行完毕之后再执行?

工作总往往会遇到异步去执行某段逻辑, 然后先处理其他事情, 处理完后再把那段逻辑

的处理结果进行汇总的场景, 这时候就需要使用线程了.

一个线程启动之后, 是异步的去执行需要执行的内容的, 不会影响主线程的流程, 往往

需要让主线程指定后, 等待子线程的完成. 这里有几种方式.

站在主线程的角度, 我们可以分为主动式和被动式.

主动式指主线程主动去检测某个标志位, 判断子线程是否已经完成. 被动式指主线程被

动的等待子线程的结束, 很明显, 比较符合人们的胃口. 就是你事情做完了, 你告诉我, 我

汇总一下, 哈哈.

1. JoinDemo(主动式)

目的:等待当前线程的 die

示例:

package com.test;

public class JoinDemo {

public static void main(String[] args) throws Exception {

//创建子线程,并启动子线程

Thread subThread = new Thread(new SubThread());

subThread.start();

//主线程处理其他工作,让子线程异步去执行

mainWork();

//主线程其他工作完毕,等待子线程的结束, 调用join系列的方法即可(可以设置超时时间)

subThread.join();

System.out.println("Now all thread done!");

}

private static void mainWork() throws Exception{

System.out.println("Main thread start work!");

//sleep

Thread.sleep(2000L);

System.out.println("Main Thread work done!");

}

/**

* 子线程类

* @author fuhg

*/

private static class SubThread implements Runnable{

public void run() {

// TODO Auto-generated method stub

System.out.println("Sub thread is starting!");

try {

Jseven

Thread.sleep(5000L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("Sub thread is stopping!");

}

}

}

2. 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(){

Jseven

System.out.println("Main thread start work!");

try {

Thread.sleep(2000L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("Main Thread work done!");

}

/**

* 子线程类

* @author fuhg

*/

private static class SubThread implements Runnable{

public void run() {

// TODO Auto-generated method stub

System.out.println("Sub thread is starting!");

try {

Thread.sleep(5000L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("Sub thread is stopping!");

}

}

}

3. CountDownDemo

上面两种情况在线程数为一两个的时候,还可以,如果需要控制的线程数很多的话,再

采取这种方式就有点过意不去了。

第一种方法, 你要调用很多个线程的 join, 特别是当你的线程不是 for 循环创建的, 而是

一个一个创建的时候.

第二种方法, 要调用很多的 future 的 get 方法, 同第一种方法.

所以去 Concurrent 库里面找找看还有什么东东吧。

CountDownLanch 是一个倒数计数器, 给一个初始值(>=0), 然后每一次调用 countDown

就会减 1, 这很符合等待多个子线程结束的场景: 一个线程结束的时候, countDown 一次, 直

到所有的线程都 countDown 了 , 那么所有子线程就都结束了.

先看看 CountDownLanch 提供的方法吧

Jseven

await: 会阻塞等待计数器减少到 0 位置. 带参数的 await 是多了等待时间.

countDown: 将当前的计数减 1

getCount(): 返回当前的计数

显而易见, 我们只需要在子线程执行之前, 赋予初始化 countDownLanch, 并赋予线程数量为初始值.

每个线程执行完毕的时候, 就 countDown 一下.主线程只需要调用 await 方法, 可以等待所有子线程执行

结束。

示例:

package com.test;

import java.util.concurrent.CountDownLatch;

public class CountDownDemo {

public static void main(String[] args) throws Exception {

//定义线程数

int subThreadNum = 5;

//取得一个倒计时器,从5开始

CountDownLatch countDownLatch = new CountDownLatch(subThreadNum);

//依次创建5个线程,并启动

for (int i = 0; i < subThreadNum; i++) {

new SubThread(2000*(i+1), countDownLatch).start();

}

//主线程工作

mainWork();

//等待所有的子线程结束

countDownLatch.await();

System.out.println("Main Thread work done!");

}

Jseven

private static void mainWork(){

System.out.println("Main thread start work!");

try {

Thread.sleep(2000L);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println("Main Thread work done!");

}

/**

* 子线程类

* @author fuhg

*/

private static class SubThread extends Thread{

private CountDownLatch countDownLatch;

private long workTime;

public SubThread(long workTime,CountDownLatch countDownLatch){

this.workTime = workTime;

this.countDownLatch = countDownLatch;

}

public void run() {

// TODO Auto-generated method stub

try {

System.out.println("Sub thread is starting!");

Thread.sleep(workTime);

System.out.println("Sub thread is stopping!");

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} finally {

//线程结束时,将计时器减一

countDownLatch.countDown();

}

}

}

}

-----------------------------------------------------end of file ---------------------------------------------------------------------------

另外还有一个并发包的类 CyclicBarrier, 这个是(子)线程之间的互相等待的利器. 栅栏, 就是把大家都

在一个地方堵住, 就像水闸, 等大家都完成了之前的操作, 再一起继续下面的操作.