java等待线程执行完毕_java并发如何等待多个线程执行完成后再继续

多线程应用中，经常会遇到这种场景：后面的处理，依赖前面的N个线程的处理结果，必须等前面的线程执行完毕后，后面的代码才允许执行。

在我不知道CyclicBarrier之前，最容易想到的就是放置一个公用的static变量，假如有10个线程，每个线程处理完上去累加下结果，然后后面用一个死循环(或类似线程阻塞的方法)，去数这个结果，达到10个，说明大家都爽完了，可以进行后续的事情了，这个想法虽然土鳖，但是基本上跟语言无关，几乎所有主流编程语言都支持。package yjmyzz.test;

public class ThreadLockTest {

public static int flag = 0;//公用变量

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

ThreadLockTest testObj = new ThreadLockTest();

final int threadNum = 10;

for (int i = 0; i 

new Thread(new MyRunable(i, testObj)).start();

}

while (true) {

if (testObj.flag >= threadNum) {

System.out.println("-----------\n所有thread执行完成！");

break;

}

Thread.sleep(10);

}

}

static class MyRunable implements Runnable {

int _i = 0;

ThreadLockTest _test;

public MyRunable(int i, ThreadLockTest test) {

this._i = i;

this._test = test;

}

@Override

public void run() {

try {

Thread.sleep((long) (Math.random() * 10));

System.out.println("thread " + _i + " done");

//利用synchronized获得同步锁

synchronized (_test) {

_test.flag += 1;

}

System.out.println("thread " + _i + " => " + _test.flag);//测试用

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

输出结果：

thread 0 done

thread 0 => 1

thread 9 done

thread 9 => 2

thread 1 done

thread 1 => 3

thread 3 done

thread 3 => 4

thread 7 done

thread 7 => 5

thread 6 done

thread 6 => 6

thread 2 done

thread 2 => 7

thread 4 done

thread 4 => 8

thread 8 done

thread 8 => 9

thread 5 done

thread 5 => 10

-----------

所有thread执行完成！

除了这个方法，还可以借助FutureTask，达到类似的效果，其get方法会阻塞线程，等到该异步处理完成。缺点就是，FutureTask调用的是Callable，必须要有返回值，所以就算你不想要返回值，也得返回点啥package yjmyzz.test;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

public class FutureTaskTest {

public static void main(String[] args) throws ExecutionException, InterruptedException {

FutureTask[] tasks = new FutureTask[10];

for (int i = 0; i 

final int j = i;

tasks[i] = new FutureTask(new Callable() {

@Override

public String call() throws Exception {

Thread.sleep((long) (Math.random() * 100));

return "task" + j + " done";

}

});

new Thread(tasks[i]).start();

}

for (int i = 0; i 

System.out.println(tasks[i].get());//依次等待所有task执行完毕

}

System.out.println("-----------\n所有task执行完成！");

}

}

执行结果：

task0 done

task1 done

task2 done

task3 done

task4 done

task5 done

task6 done

task7 done

task8 done

task9 done

-----------

所有task执行完成！

此外，Thread的Join方法也可以实现类似的效果，主要代码如下：public static void main(String[] args) throws Exception {

final int threadNum = 10;

Thread[] threads = new Thread[threadNum];

for (int i = 0; i 

threads[i] = new Thread(new MyRunable(i));

threads[i].start();

}

for (int i = 0; i 

threads[i].join();

}

System.out.println("-----------\n所有thread执行完成！");

}

当然，这个需求最“正统”的解法应该是使用CyclicBarrier，它可以设置一个所谓的“屏障点”(或称集合点)，好比在一项团队活动中，每个人都是一个线程，但是规定某一项任务开始前，所有人必须先到达集合点，集合完成后，才能继续后面的任务。package yjmyzz.test;

import java.util.concurrent.CyclicBarrier;

public class ThreadTest {

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

final int threadNum = 10;

CyclicBarrier cb = new CyclicBarrier(threadNum + 1);//注意：10个子线程 + 1个主线程

for (int i = 0; i 

new Thread(new MyRunable(cb, i)).start();

}

cb.await();

System.out.println("-----------\n所有thread执行完成！");

}

static class MyRunable implements Runnable {

CyclicBarrier _cb;

int _i = 0;

public MyRunable(CyclicBarrier cb, int i) {

this._cb = cb;

this._i = i;

}

@Override

public void run() {

try {

Thread.sleep((long) (Math.random() * 100));

System.out.println("thread " + _i + " done，正在等候其它线程完成...");

_cb.await();

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

thread 9 done，正在等候其它线程完成...

thread 5 done，正在等候其它线程完成...

thread 0 done，正在等候其它线程完成...

thread 6 done，正在等候其它线程完成...

thread 4 done，正在等候其它线程完成...

thread 2 done，正在等候其它线程完成...

thread 3 done，正在等候其它线程完成...

thread 8 done，正在等候其它线程完成...

thread 7 done，正在等候其它线程完成...

thread 1 done，正在等候其它线程完成...

-----------

所有thread执行完成！