Java程式有的時候在主執行緒中會建立多個執行緒去執行任務，然後在主執行緒執行完畢之前，把所有執行緒的任務進行彙總，以前可以用執行緒的join方法，但是這個方法不夠靈活，我們可以使用CountDownLatch類，實現更優雅,而且使用執行緒池的話，可沒有辦法呼叫執行緒的join方法的呀！

一.簡單使用CountDownLatch

　　直接使用執行緒：

package com.example.demo.study;

import java.util.concurrent.CountDownLatch;

public class Study0215 {
  //這裡相當於新建一個初始值為2的計數器
  private static volatile CountDownLatch countDownLatch = new CountDownLatch(2);
  
  public static void main(String[] args) throws InterruptedException {
    
    new Thread(()->{
      try {
        Thread.sleep(1000);
        System.out.println("執行緒一執行完畢");
      } catch (Exception e) {
        
      }finally {
        //每呼叫這個方法計數器減一
        countDownLatch.countDown();
      }
      
    }).start();
    
    new Thread(()->{
      try {
        Thread.sleep(1000);
        System.out.println("執行緒二執行完畢");
      } catch (Exception e) {
        
      }finally {
        countDownLatch.countDown();
      }
      
    }).start();
    
    System.out.println("兩個執行緒已經全部啟動");
    //只要呼叫了這個方法之後，主執行緒會阻塞，直到計數器countDownLatch變成0就會返回
    countDownLatch.await();
    System.out.println("執行完畢");
    
  }
  
}

實際中儘量少直接操作執行緒，而是使用執行緒池：

package com.example.demo.study;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Study0215 {
  // 這裡相當於新建一個初始值為2的計數器
  private static volatile CountDownLatch countDownLatch = new CountDownLatch(2);

  public static void main(String[] args) throws InterruptedException {
    //建立執行緒池
    ExecutorService pool = Executors.newFixedThreadPool(2);
    //將任務一丟進執行緒池
    pool.submit(() -> {
      try {
        Thread.sleep(1000);
        System.out.println("執行緒一執行完畢");
      } catch (Exception e) {

      } finally {
        // 每呼叫這個方法計數器減一
        countDownLatch.countDown();
      }
    });
    //任務二丟進執行緒池
    pool.submit(() -> {
      try {
        Thread.sleep(1000);
        System.out.println("執行緒二執行完畢");
      } catch (Exception e) {

      } finally {
        countDownLatch.countDown();
      }
    });

    System.out.println("兩個執行緒已經全部啟動");
    // 只要呼叫了這個方法之後，主執行緒會阻塞，直到計數器countDownLatch變成0就會返回
    countDownLatch.await();
    System.out.println("執行完畢");

  }

}

二.await方法

　　看下面的圖，可以知道這個CountDownLatch類內部有個工具類Sync實現了AQS，然後CountDownLatch中的方法都是呼叫工具類Sync去操作的，emmm....跟前面說過的ReentrantLock類結構是一樣的；

我們看看CountDownLatch構造器傳遞的數其實就是設定AQS中state的值：

//實際上呼叫把值傳遞給了Sync，也就是設定了AQS中的state
public CountDownLatch(int count) {
  if (count < 0) throw new IllegalArgumentException("count < 0");
  this.sync = new Sync(count);
}
Sync(int count) {
  setState(count);
}

我們再看看await方法：

//當前執行緒呼叫了await方法之後，當前執行緒就會給阻塞，直到以下兩種情況：
//1.其他執行緒呼叫了countDown方法將計數器減到0之後，該執行緒就返回了；
//2.其他執行緒呼叫了當前的執行緒的中斷方法，當前執行緒丟擲異常InterruptedException
public void await() throws InterruptedException {
  sync.acquireSharedInterruptibly(1);
}

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
  //當前執行緒被中斷就丟擲異常
  if (Thread.interrupted())
    throw new InterruptedException();
  //檢視計數器中的值是不是0，不過不是0，就進入AQS等待佇列等待；
  if (tryAcquireShared(arg) < 0)
    doAcquireSharedInterruptibly(arg);
}

protected int tryAcquireShared(int acquires) {
  return (getState() == 0) ? 1 : -1;
}

三.countDown方法

public void countDown() {
  sync.releaseShared(1);
}

public final boolean releaseShared(int arg) {
  //tryReleaseShared方法返回false，說明當前計數器的值減一成功
  //返回true，說明計數器的值此時為0，那就要喚醒因為呼叫了CountDownLatch而阻塞的執行緒
  if (tryReleaseShared(arg)) {
    doReleaseShared();
    return true;
  }
  return false;
}

protected boolean tryReleaseShared(int releases) {
  //一個無限迴圈
  for (;;) {
    //獲取state的值
    int c = getState();
    //如果state為0，返回false
    if (c == 0)
      return false;
    //否則就把state減一然後用CAS更新到state
    int nextc = c-1;
    if (compareAndSetState(c,nextc))
      return nextc == 0;
  }
}

四.getState方法

　　這個方法獲取計數器的值，其實就是獲取AQS中的state的值；

int getCount() {
  return getState();
}
protected final int getState() {
  return state;
}

　　其實CountDownLatch比較容易，功能和Thread的join方法一樣，只不過更靈活，基於AQS實現，在初始化的時候設定state的值，當執行緒呼叫CountDownLatch的await方法的時候，當前執行緒就會被丟到AQS的阻塞佇列掛起；然後當其他執行緒呼叫了countDown方法，其實就是將state減一，當state等於0的時候，就會喚醒所有因為呼叫await方法而阻塞的執行緒；

以上就是詳解Java執行緒同步器CountDownLatch的詳細內容，更多關於Java CountDownLatch的資料請關注我們其它相關文章！