概述

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實際上也就是這麼做的。

從結構上來看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()方法一直阻塞的情況。