1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public class Test {
public static void main(String[] args) throws InterruptedException {
CountDownLatch latch = new CountDownLatch(3); //三个个工人的协作
Worker worker1 = new Worker("张三", 4000, latch);
Worker worker2 = new Worker("李四", 2000, latch);
Worker worker3 = new Worker("王五", 5000, latch);
worker1.start();
worker2.start();
worker3.start();
// 主线程阻塞，等待所有子线程完成（调用latch.countDown()）
latch.await();
System.out.println("主线程：工作完成");
}
}
/**
* 工人类-子线程
*/
class Worker extends Thread{
private String name; // 工人姓名
private long time; // 工作时间（单位：毫秒）
private CountDownLatch latch; // 计数锁存器
public Worker(String name, long time, CountDownLatch latch) {
this.name = name;
this.time = time;
this.latch = latch;
}
private void doWork() throws InterruptedException {
Thread.sleep(time);
}
public void run() {
try {
doWork(); // 工作中。。。
System.out.println("工人: " + name + " 完成工作");
} catch (InterruptedException e) {
System.out.println("工人: " + name + " 工作出现意外");
} finally {
latch.countDown(); //工人完成工作，计数器减一
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class Test {
private static final ExecutorService executor = Executors.newCachedThreadPool();
private static Random random = new Random();
private static long timeout = 4L;
/**
* 启动多个子任务
*/
public static void startMoreTask() {
List<Callable<Integer>> subTasks = new ArrayList<Callable<Integer>>(); // 子任务集合
List<Integer> subTaskResult = new ArrayList<Integer>(); // 子任务的返回集合
// 1.初始化10个子任务
for (int i = 1; i <= 10; i ++) {
SubTask subTask = new SubTask("子线程-" + i, random.nextInt(10)); // 子线程随机在10秒内完成
subTasks.add(subTask);
}
// 2.执行所有的子任务
try {
List<Future<Integer>> futures = executor.invokeAll(subTasks);
for (Future<Integer> future : futures) {
try {
Integer result = future.get(timeout, TimeUnit.SECONDS); // 设置每个子任务的执行时间不得超过4秒
subTaskResult.add(result);
} catch (ExecutionException | TimeoutException e) {
future.cancel(true); // 当出现执行异常和超时异常时，终止该子任务
}
}
} catch (InterruptedException e) {
System.out.println("任务执行异常：" + e.getMessage());
}
}
public static void main(String[] args) {
// subTask1测试超时的情况
SubTask subTask1 = new SubTask("子线程 - 1", 10);
Future<Integer> future1 = executor.submit(subTask1);
Integer result1 = null;
try {
result1 = future1.get(5, TimeUnit.SECONDS); // 设置子任务的执行时间不得超过5秒
} catch (InterruptedException e) {
System.out.println("线程中断出错");
future1.cancel(true);// 中断执行此任务的线程
} catch (ExecutionException e) {
System.out.println("线程服务出错");
future1.cancel(true);// 中断执行此任务的线程
} catch (TimeoutException e) {// 超时异常
System.out.println("线程执行超时");
future1.cancel(true);// 中断执行此任务的线程
}
System.out.println("subTask1运行结果:" + (result1 == null ? "null" : result1));
// subTask2测试拿到子线程返回结果的情况
SubTask subTask2 = new SubTask("子线程 - 2", 5);
Future<Integer> future2 = executor.submit(subTask2);
Integer result2 = null;
try {
result2 = future2.get(10, TimeUnit.SECONDS); // 设置子任务的执行时间不得超过10秒
} catch (InterruptedException e) {
System.out.println("线程中断出错");
future2.cancel(true);// 中断执行此任务的线程
} catch (ExecutionException e) {
System.out.println("线程服务出错");
future2.cancel(true);// 中断执行此任务的线程
} catch (TimeoutException e) {// 超时异常
System.out.println("线程执行超时");
future2.cancel(true);// 中断执行此任务的线程
}
System.out.println("subTask2运行结果:" + (result2 == null ? "null" : result2));
}
}
class SubTask implements Callable<Integer> {
private String name; // 子线程名
private int second; // 子线程完成需要的时间（秒）
public SubTask (String name, int second) {
this.name = name;
this.second = second;
}
@Override
public Integer call() throws Exception {
System.out.println("#子线程-" + name + " 开始");
Thread.sleep(second * 1000L);
System.out.println("#子线程-" + name + " 结束，耗时秒数: " + second);
return second;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.Random;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
public class CyclicBarrierTest {
private static ExecutorService executor = Executors.newFixedThreadPool(10, new ThreadFactory() { // 创建固定大小的守护线程池
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
return t;
}
});
public static void main(String[] args) throws Exception {
// 初始化CyclicBarrier
//CyclicBarrier barrier = new CyclicBarrier(10); // 1.可以只传入一个参数：给定数量的参与者（线程）
CyclicBarrier barrier = new CyclicBarrier(10, new Runnable() { // 2.也可以传入第二个参数，当所有的子线程到达某个公共屏障点，进入barrier线程
@Override
public void run() {
System.out.println("#所有任务初始化完成");
}
});
// 使用线程池
for (int i = 1; i <= barrier.getParties(); i ++) { // getParties() 返回要求启动此 barrier 的参与者数目
String name = "子任务-" + i;
executor.submit(new Task(name, barrier));
}
// 启动所有子线程
executor.shutdown();
Thread.sleep(Integer.MAX_VALUE);
}
}
/**
* 子任务：初始化、执行
*/
class Task implements Runnable {
private String name;
private CyclicBarrier barrier;
public Task (String name, CyclicBarrier barrier) {
this.name = name;
this.barrier = barrier;
}
@Override
public void run() {
try {
// 子任务初始化
int sleepTime = new Random().nextInt(10);
Thread.sleep(sleepTime * 1000L);
System.out.println("子任务：" + this.name + " 初始化完成，使用" + sleepTime + "秒，此时已经初始化完成的子任务数量：" + barrier.getNumberWaiting()); // getNumberWaiting() 返回当前在屏障处等待的参与者数目
// 在所有参与者都已经在此屏障上调用 await 方法之前将一直等待,或者超出了指定的等待时间
barrier.await(); // 也可以换为await(long timeout, TimeUnit unit) 方法设定超时时间
// 子任务执行
System.out.println("子任务：" + this.name + " 执行完毕");
} catch (Exception e) {}
}
}