Java的CountDownLatch和CyclicBarrier的理解和区别

CountDownLatch和CyclicBarrier的功能看起来很相似，不易区分，有一种谜之的神秘。本文将通过通俗的例子并结合代码讲解两者的使用方法和区别。

CountDownLatch和CyclicBarrier都是java.util.concurrent包下面的多线程工具类。

从字面上理解，CountDown表示减法计数，Latch表示门闩的意思，计数为0的时候就可以打开门闩了。Cyclic Barrier表示循环的障碍物。两个类都含有这一个意思：对应的线程都完成工作之后再进行下一步动作，也就是大家都准备好之后再进行下一步。然而两者最大的区别是，进行下一步动作的动作实施者是不一样的。这里的“动作实施者”有两种，一种是主线程（即执行main函数），另一种是执行任务的其他线程，后面叫这种线程为“其他线程”，区分于主线程。对于CountDownLatch，当计数为0的时候，下一步的动作实施者是main函数；对于CyclicBarrier，下一步动作实施者是“其他线程”。

下面举例说明：

对于CountDownLatch，其他线程为游戏玩家，比如英雄联盟，主线程为控制游戏开始的线程。在所有的玩家都准备好之前，主线程是处于等待状态的，也就是游戏不能开始。当所有的玩家准备好之后，下一步的动作实施者为主线程，即开始游戏。

我们使用代码模拟这个过程，我们模拟了三个玩家，在三个玩家都准备好之后，游戏才能开始。代码的输出结果为：

正在等待所有玩家准备好

player0 已经准备好了, 所使用的时间为 1.235s

player2 已经准备好了, 所使用的时间为 1.279s

player3 已经准备好了, 所使用的时间为 1.358s

player1 已经准备好了, 所使用的时间为 2.583s

开始游戏

1

2

3

4

5

6

CountDownLatch的代码：

import java.util.Random;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

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

CountDownLatch latch = new CountDownLatch(4);

for(int i = 0; i < latch.getCount(); i++){

new Thread(new MyThread(latch), "player"+i).start();

}

System.out.println("正在等待所有玩家准备好");

latch.await();

System.out.println("开始游戏");

}

private static class MyThread implements Runnable{

private CountDownLatch latch ;

public MyThread(CountDownLatch latch){

this.latch = latch;

}

@Override

public void run() {

try {

Random rand = new Random();

int randomNum = rand.nextInt((3000 - 1000) + 1) + 1000;//产生1000到3000之间的随机整数

Thread.sleep(randomNum);

System.out.println(Thread.currentThread().getName()+" 已经准备好了, 所使用的时间为 "+((double)randomNum/1000)+"s");

latch.countDown();

} 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

对于CyclicBarrier，假设有一家公司要全体员工进行团建活动，活动内容为翻越三个障碍物，每一个人翻越障碍物所用的时间是不一样的。但是公司要求所有人在翻越当前障碍物之后再开始翻越下一个障碍物，也就是所有人翻越第一个障碍物之后，才开始翻越第二个，以此类推。类比地，每一个员工都是一个“其他线程”。当所有人都翻越的所有的障碍物之后，程序才结束。而主线程可能早就结束了，这里我们不用管主线程。

我们使用代码来模拟上面的过程。我们设置了三个员工和三个障碍物。可以看到所有的员工翻越了第一个障碍物之后才开始翻越第二个的，下面是运行结果：

main function is finished.

队友1, 通过了第0个障碍物, 使用了 1.432s

队友0, 通过了第0个障碍物, 使用了 1.465s

队友2, 通过了第0个障碍物, 使用了 2.26s

队友1, 通过了第1个障碍物, 使用了 1.542s

队友0, 通过了第1个障碍物, 使用了 2.154s

队友2, 通过了第1个障碍物, 使用了 2.556s

队友1, 通过了第2个障碍物, 使用了 1.426s

队友2, 通过了第2个障碍物, 使用了 2.603s

队友0, 通过了第2个障碍物, 使用了 2.784s

1

2

3

4

5

6

7

8

9

10

代码：

package com.huai.thread;

import java.util.Random;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierTest {

public static void main(String[] args) {

CyclicBarrier barrier = new CyclicBarrier(3);

for(int i = 0; i < barrier.getParties(); i++){

new Thread(new MyRunnable(barrier), "队友"+i).start();

}

System.out.println("main function is finished.");

}

private static class MyRunnable implements Runnable{

private CyclicBarrier barrier;

public MyRunnable(CyclicBarrier barrier){

this.barrier = barrier;

}

@Override

public void run() {

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

try {

Random rand = new Random();

int randomNum = rand.nextInt((3000 - 1000) + 1) + 1000;//产生1000到3000之间的随机整数

Thread.sleep(randomNum);

System.out.println(Thread.currentThread().getName() + ", 通过了第"+i+"个障碍物, 使用了 "+((double)randomNum/1000)+"s");

this.barrier.await();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException 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

总结：CountDownLatch和CyclicBarrier都有让多个线程等待同步然后再开始下一步动作的意思，但是CountDownLatch的下一步的动作实施者是主线程，具有不可重复性；而CyclicBarrier的下一步动作实施者还是“其他线程”本身，具有往复多次实施动作的特点。