文章目录
- I CountDownLatch 使用场景举例
- II CountDownLatch 简单线程阻塞示例
- III CountDownLatch 多个线程联合阻塞示例
I CountDownLatch 使用场景举例
1. 单个阻塞等待单个线程 : 初始化 CountDownLatch 时 , 设置其计数为 1 , 在线程 A 中调用 await() 阻塞 , 然后在线程 B 中执行操作 , 之后调用 countDown() 方法 , 计数 - 1 , 线程 A 阻塞解除 ;
2. 单个阻塞等待多个线程 : 初始化 CountDownLatch 时 , 设置其计数为 2 , 在线程 A 中调用 await() 阻塞 ; 然后在线程 B 中执行操作 , 调用 countDown() 方法 , 计数 - 1 ; 同时在线程 C 中执行更长时间的操作 , 调用 countDown() 方法 , 计数 - 1 ; 线程 B 和 C 的操作执行完毕后 , 其计数才减为 0 , 此时线程 A 中的阻塞解除 ;
3. 多个线程阻塞等待单个线程 : 多个线程中调用 CountDownLatch 对象 await() 方法阻塞 , 在另外一个线程中将计数 countDown() 为 0 , 这些线程即可执行 ;
4. 多个线程阻塞等待多个线程 : 多个线程中调用 CountDownLatch 对象 await() 方法阻塞 , 在另外多个线程中将计数 countDown() 为 0 , 被阻塞这些线程即可执行 ;
5. CountDownLatch 使用场景 :
- ① 单线程等待单线程 : 线程 A 阻塞 , 等待线程 B 执行完毕后 , 在执行线程 A 操作 ;
- ② 单线程等待多线程 : 线程 A 阻塞 , 等待线程 B , C , D 等线程执行完毕 , 在执行线程 A 操作 ;
- ③ 单线程与多线程互相阻塞 : 线程 B , C , D , 先被 new CountDownLatch ( 1 ) 对象阻塞住 , 在线程 A 中先解除 B , C , D 的阻塞 , 然后 B , C , D 这三个线程才能继续执行 , 线程 A 解除之后 , 马上被 new CountDownLatch ( 3 ) 对象阻塞 , B , C , D 三个线程执行完后 , 每个线程计数减一 , 之后解除线程 A 阻塞 , 继续执行线程 A 的内容 ;
- ④ 单线程与多线程互相阻塞并设置超时时间 : 在上述 ③ 情况的基础上 , 加上超时等待 , 如果 B , C , D 线程在指定时间内没有执行完毕 , 那么线程 A 也解除阻塞 , 继续向下执行之后的代码 ;
II CountDownLatch 简单线程阻塞示例
1. 代码说明 : 子线程运行后调用 CountDownLatch 的 await 方法阻塞 , 在主线程中调用 countDown 方法将计数减为 0 , 子线程解除阻塞 ;
2. 代码示例 :
代码语言：javascript复制import java.util.concurrent.CountDownLatch;
/**
* 子线程运行后调用 CountDownLatch 的 await 方法阻塞 ,
* 在主线程中调用 countDown 方法将计数减为 0 , 子线程解除阻塞
*/
public class CountDownLatchDemo {
public static void main(String[] args) {
System.out.println("1. 主线程 : 开始运行 , 创建 CountDownLatch 对象初始计数为 1");
//创建 CountDownLatch 对象 , 初始计数为 1
CountDownLatch countDownLatch = new CountDownLatch(1);
System.out.println("2. 主线程 : 创建子线程并运行");
//创建子线程 , 并设置其 countDownLatch 对象, 运行子线程
MyThread myThread = new MyThread(countDownLatch);
myThread.start();
System.out.println("3. 主线程 : 调用 countDownLatch.countDown() 方法");
countDownLatch.countDown();
System.out.println("4. 主线程 : 运行结束");
}
static class MyThread extends Thread{
/**
* 用于阻塞的 CountDownLatch 对象
*/
CountDownLatch countDownLatch;
/**
* 主线程中传入 CountDownLatch 对象 , 两个线程公用一个该对象
* @param countDownLatch
*/
public MyThread(CountDownLatch countDownLatch) {
this.countDownLatch = countDownLatch;
}
@Override
public void run() {
super.run();
try {
System.out.println("1. 子线程 : 开始运行 , 并调用 countDownLatch.await() 方法阻塞");
//阻塞子线程
countDownLatch.await();
System.out.println("2. 子线程 : CountDownLatch 对象计数为 0 , 子线程继续运行并结束");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}3. 执行结果 :
代码语言：javascript复制1. 主线程 : 开始运行 , 创建 CountDownLatch 对象初始计数为 1
2. 主线程 : 创建子线程并运行
3. 主线程 : 调用 countDownLatch.countDown() 方法
1. 子线程 : 开始运行 , 并调用 countDownLatch.await() 方法阻塞
4. 主线程 : 运行结束
2. 子线程 : CountDownLatch 对象计数为 0 , 子线程继续运行并结束III CountDownLatch 多个线程联合阻塞示例
1. 情景描述 : 运动员赛跑 , 1 个裁判 , 4 个运动员 , 4 个运动员首先等待裁判发令 , 才能开始跑 , 裁判发令后在终点等待 4 个运动员都达到终点后 , 在宣布成绩 ;
2. 线程模型分析 :
- ① 线程 : 裁判员是一个单独的线程 , 4 个运动员是 4 个独立的线程 ;
- ② CountDownLatch : 两种 CountDownLatch 对象 , 一个用于阻塞裁判员线程 , 一个用于阻塞运动员线程 ;
- ③ 运动员线程 : 四个运动员线程一开始运行后 , 马上调用 new CountDownLatch(1) 对象阻塞住 , 不能向后运行 ;
- ④ 裁判员线程 : 裁判员线程要等四个运动员线程启动后才能执行 , 先调用 countDown 将四个运动员线程取消阻塞 , 然后调用new CountDownLatch(4) 对象 的 await 阻塞 , 每个运动员线程跑到终点后 , 调用 countDown 方法 , 四个运动员全部到达终点后 , 裁判员解除阻塞 , 宣布成绩 ;
3. 代码示例 :
代码语言：javascript复制import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 情景描述 : 运动员赛跑 , 1 个裁判 , 4 个运动员 ,
* 4 个运动员首先等待裁判发令 , 才能开始跑 ,
* 裁判发令后在终点等待 4 个运动员都达到终点后 , 在宣布成绩 ;
*
* 线程模型分析 :
*
* ① 线程 : 裁判员是一个单独的线程 , 4 个运动员是 4 个独立的线程 ;
* ② CountDownLatch : 两种 CountDownLatch 对象 , 一个用于阻塞裁判员线程 , 一个用于阻塞运动员线程 ;
* ③ 运动员线程 ( 子线程 ) : 四个运动员线程一开始运行后 , 马上调用 new CountDownLatch(1) 对象阻塞住 , 不能向后运行 ;
* ④ 裁判员线程 ( 主线程 ) : 裁判员线程要等四个运动员线程启动后才能执行 , 先调用 countDown 将四个运动员线程取消阻塞 ,
* 然后调用new CountDownLatch(4) 对象 的 await 阻塞 , 每个运动员线程跑到终点后 ,
* 调用 countDown 方法 , 四个运动员全部到达终点后 , 裁判员解除阻塞 , 宣布成绩 ;
*/
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
//用于存储四个运动员的成绩
int[] grades = new int[4];
//四个运动员线程的线程池
ExecutorService executorService = Executors.newCachedThreadPool();
//阻塞运动员线程的倒计时锁对象 , 需要裁判员线程解锁
CountDownLatch runnerLatch = new CountDownLatch(1);
//阻塞裁判线程的倒计时锁对象 , 需要四个运动员线程解锁
CountDownLatch judgeLatch = new CountDownLatch(4);
//创建并执行运动员线程 , 使用线程池机制执行
for(int i = 0; i < 4; i ){
int finalI = i;
//创建运动员线程
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
System.out.println( finalI " 号运动员准备完毕 , 等待裁判员发令");
runnerLatch.await();
System.out.println( finalI " 号运动员起跑");
//设置运动员成绩 , 这里用一个随机数代替
grades[finalI] = (int) (Math.random() * 10000);
Thread.sleep(grades[finalI]);
//通知裁判员到达终点
judgeLatch.countDown();
System.out.println( finalI " 号运动员到达终点");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//使用线程池调度运行该线程
executorService.execute(runnable);
}
System.out.println("裁判员 : 发令 , 起跑");
//裁判员线程在运动员准备完毕后 , 解除上述 4 个运动员线程的阻塞 , 即运动员起跑
runnerLatch.countDown();
System.out.println("裁判员 : 在终点等待 4 名运动员");
//裁判员线程阻塞, 等待 4 个运动员线程执行完毕
judgeLatch.await();
System.out.println("裁判员 : 运动员全部到达终点成绩为 0 号 : " grades[0]
" , 1 号 : " grades[1]
" , 2 号 : " grades[2]
" , 3 号 : " grades[3]);
}
}4. 执行结果 :
代码语言：javascript复制裁判员 : 发令 , 起跑
裁判员 : 在终点等待 4 名运动员
2 号运动员准备完毕 , 等待裁判员发令
2 号运动员起跑
1 号运动员准备完毕 , 等待裁判员发令
1 号运动员起跑
0 号运动员准备完毕 , 等待裁判员发令
0 号运动员起跑
3 号运动员准备完毕 , 等待裁判员发令
3 号运动员起跑
1 号运动员到达终点
2 号运动员到达终点
0 号运动员到达终点
3 号运动员到达终点
裁判员 : 运动员全部到达终点成绩为 0 号 : 5601 , 1 号 : 1763 , 2 号 : 4700 , 3 号 : 9650
