【Java 并发编程】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. 代码示例 :

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();
            }

        }
    }

}


  

 

  
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
 

3. 执行结果 :

1. 主线程 : 开始运行 , 创建 CountDownLatch 对象初始计数为 1
2. 主线程 : 创建子线程并运行
3. 主线程 : 调用 countDownLatch.countDown() 方法
1. 子线程 : 开始运行 , 并调用 countDownLatch.await() 方法阻塞
4. 主线程 : 运行结束
2. 子线程 : CountDownLatch 对象计数为 0 , 子线程继续运行并结束

  

 

  
1
  
2
  
3
  
4
  
5
  
6
 

III CountDownLatch 多个线程联合阻塞示例

1. 情景描述 : 运动员赛跑 , 1 个裁判 , 4 个运动员 , 4 个运动员首先等待裁判发令 , 才能开始跑 , 裁判发令后在终点等待 4 个运动员都达到终点后 , 在宣布成绩 ;

2. 线程模型分析 :

• ① 线程 : 裁判员是一个单独的线程 , 4 个运动员是 4 个独立的线程 ;
• ② CountDownLatch : 两种 CountDownLatch 对象 , 一个用于阻塞裁判员线程 , 一个用于阻塞运动员线程 ;
• ③ 运动员线程 : 四个运动员线程一开始运行后 , 马上调用 new CountDownLatch(1) 对象阻塞住 , 不能向后运行 ;
• ④ 裁判员线程 : 裁判员线程要等四个运动员线程启动后才能执行 , 先调用 countDown 将四个运动员线程取消阻塞 , 然后调用new CountDownLatch(4) 对象 的 await 阻塞 , 每个运动员线程跑到终点后 , 调用 countDown 方法 , 四个运动员全部到达终点后 , 裁判员解除阻塞 , 宣布成绩 ;

3. 代码示例 :

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]);


    }



}


  

 

  
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
 

4. 执行结果 :

裁判员 : 发令 , 起跑
裁判员 : 在终点等待 4 名运动员
2 号运动员准备完毕 , 等待裁判员发令
2 号运动员起跑
1 号运动员准备完毕 , 等待裁判员发令
1 号运动员起跑
0 号运动员准备完毕 , 等待裁判员发令
0 号运动员起跑
3 号运动员准备完毕 , 等待裁判员发令
3 号运动员起跑
1 号运动员到达终点
2 号运动员到达终点
0 号运动员到达终点
3 号运动员到达终点
裁判员 : 运动员全部到达终点成绩为 0 号 : 5601 , 1 号 : 1763 , 2 号 : 4700 , 3 号 : 9650

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
 

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/100607549