详解Java线程同步器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("执行完毕");

  }

}

//实际上调用把值传递给了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方法之后，当前线程就会给阻塞，直到以下两种情况：
//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;
}

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

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