CountDownLatch使用以及原理

桃扇骨 2022-05-13 09:18 233阅读 0赞

# 概述 #

CountDownLatch是一个用来控制并发的很常见的工具，它允许一个或者多个线程等待其他的线程执行到某一操作，比如说需要去解析一个excel的数据，为了更快的解析则每个sheet都使用一个线程去进行解析，但是最后的汇总数据的工作则需要等待每个sheet的解析工作完成之后才能进行，这就可以使用CountDownLatch。

# 使用 #

例子：

这里有三个线程（main，thread1，thread2），其中main线程将调用countDownLatch的await方法去等待另外两个线程的某个操作的结束（调用countDownLatch的countDown方法）。

1.  `public class CountDownLatchDemo {`
2.   
3.  `public static void main(String[] args) throws InterruptedException{`
4.   
5.  `CountDownLatch countDownLatch = new CountDownLatch(2){`
6.  `@Override`
7.  `public void await() throws InterruptedException {`
8.  `super.await();`
9.  `System.out.println(Thread.currentThread().getName() + " count down is ok");`
10. `}`
11. `};`
12.  
13. `Thread thread1 = new Thread(new Runnable() {`
14. `@Override`
15. `public void run() {`
16. `//do something`
17. `try {`
18. `Thread.sleep(1000);`
19. `} catch (InterruptedException e) {`
20. `e.printStackTrace();`
21. `}`
22. `System.out.println(Thread.currentThread().getName() + " is done");`
23. `countDownLatch.countDown();`
24. `}`
25. `}, "thread1");`
26.  
27. `Thread thread2 = new Thread(new Runnable() {`
28. `@Override`
29. `public void run() {`
30. `//do something`
31. `try {`
32. `Thread.sleep(2000);`
33. `} catch (InterruptedException e) {`
34. `e.printStackTrace();`
35. `}`
36. `System.out.println(Thread.currentThread().getName() + " is done");`
37. `countDownLatch.countDown();`
38. `}`
39. `}, "thread2");`
40.  
41.  
42. `thread1.start();`
43. `thread2.start();`
44.  
45. `countDownLatch.await();`
46. `}`
47.  
48. `}`

输出：

1.  `test thread1 is done`
2.  `test thread2 is done`
3.  `test thread3 is done`
4.  `test thread3 count down is ok`
5.  `main count down is ok`

这里的CountDownLatch的构造函数中使用的int型变量的意思是需要等待多少个操作 的完成。这里是2所以需要等到调用了两次countDown()方法之后主线程的await()方法才会返回。这意味着如果我们错误的估计了需要等待的操作的个数或者在某个应该调用countDown()方法的地方忘记了调用那么将意味着await()方法将永远的阻塞下去。

# 实现原理 #

CountDownLatch类实际上是使用计数器的方式去控制的，不难想象当我们初始化CountDownLatch的时候传入了一个int变量这个时候在类的内部初始化一个int的变量，每当我们调用countDownt()方法的时候就使得这个变量的值减1，而对于await()方法则去判断这个int的变量的值是否为0，是则表示所有的操作都已经完成，否则继续等待。

实际上如果了解AQS的话应该很容易想到可以使用AQS的共享式获取同步状态的方式来完成这个功能。而CountDownLatch实际上也就是这么做的。

![Center][]

从结构上来看CountDownLatch的实现还是很简单的，通过很常见的继承AQS的方式来完成自己的同步器。

CountDownLatch的同步器实现：

1.  `private static final class Sync extends AbstractQueuedSynchronizer {`
2.  `private static final long serialVersionUID = 4982264981922014374L;`
3.  `//初始化state`
4.  `Sync(int count) {`
5.  `setState(count);`
6.  `}`
7.   
8.  `int getCount() {`
9.  `return getState();`
10. `}`
11. `//尝试获取同步状态`
12. `//只有当同步状态为0的时候返回大于0的数1`
13. `//同步状态不为0则返回-1`
14. `protected int tryAcquireShared(int acquires) {`
15. `return (getState() == 0) ? 1 : -1;`
16. `}`
17. `//自旋+CAS的方式释放同步状态`
18. `protected boolean tryReleaseShared(int releases) {`
19. `// Decrement count; signal when transition to zero`
20. `for (;;) {`
21. `int c = getState();`
22. `if (c == 0)`
23. `return false;`
24. `int nextc = c-1;`
25. `if (compareAndSetState(c, nextc))`
26. `return nextc == 0;`
27. `}`
28. `}`
29. `}`

比较关键的地方是tryAquireShared()方法的实现，因为在父类的AQS中aquireShared()方法在调用tryAquireShared()方法的时候的判断依据是返回值是否大于零。

1.  `public final void acquireShared(int arg) {`
2.  `if (tryAcquireShared(arg) < 0)`
3.  `//失败则进入等待队列`
4.  `doAcquireShared(arg);`
5.  `}`

同步器的实现相对都比较简单，主要思路和上面基本一致。

CountDownLatch的主要方法（本身代码量就很少就直接贴了）

1.  `public class CountDownLatch {`
2.  `private static final class Sync extends AbstractQueuedSynchronizer {`
3.  `private static final long serialVersionUID = 4982264981922014374L;`
4.   
5.  `Sync(int count) {`
6.  `setState(count);`
7.  `}`
8.   
9.  `int getCount() {`
10. `return getState();`
11. `}`
12.  
13. `protected int tryAcquireShared(int acquires) {`
14. `return (getState() == 0) ? 1 : -1;`
15. `}`
16.  
17. `protected boolean tryReleaseShared(int releases) {`
18. `// Decrement count; signal when transition to zero`
19. `for (;;) {`
20. `int c = getState();`
21. `if (c == 0)`
22. `return false;`
23. `int nextc = c-1;`
24. `if (compareAndSetState(c, nextc))`
25. `return nextc == 0;`
26. `}`
27. `}`
28. `}`
29.  
30. `private final Sync sync;`
31.  
32. `//初始化一个同步器`
33. `public CountDownLatch(int count) {`
34. `if (count < 0) throw new IllegalArgumentException("count < 0");`
35. `this.sync = new Sync(count);`
36. `}`
37. `//调用同步器的acquireSharedInterruptibly方法`
38. `//并且是响应中断的`
39. `public void await() throws InterruptedException {`
40. `sync.acquireSharedInterruptibly(1);`
41. `}`
42.  
43. `//调用同步器的releaseShared方法去让state减1`
44. `public void countDown() {`
45. `sync.releaseShared(1);`
46. `}`
47. `//获取剩余的count`
48. `public long getCount() {`
49. `return sync.getCount();`
50. `}`
51.  
52. `public String toString() {`
53. `return super.toString() + "[Count = " + sync.getCount() + "]";`
54. `}`
55. `}`

最后：由于CountDownLatch需要开发人员很明确需要等待的条件，否则很容易造成await()方法一直阻塞的情况。

[Center]: /images/20220513/fd0ae441784442f2a75fbae8fa1989ee.png