本文主要学习了JUC提供的三个常用的辅助类。
1 CountDownLatch
1.1 简介
一个同步辅助类，用于将线程阻塞某段时间，等其他线程完成后，唤醒被阻塞的线程继续执行。
CountDownLatch在内部维护了一个计数器，需要在构造方法中传入一个非负整数值。
在线程中通过countDown()方法将计数器减一，当线程调用了await()方法后，会判断计数器是否为0，如果不为0会阻塞当前线程，等计数器为0后继续执行。
在当前计数到达零之前，等待线程会一直阻塞，计数为零时会释放所有等待线程。并且计数器无法被重置，因此只能使用一次，不能重复使用。
底层使用LockSupport用于阻塞和唤醒线程。
1.2 源码分析
1.2.1 构造方法
构造方法需要传入一个非负整数，否则会抛出异常。
通过构造方法将传入的值，设置为AQS中state字段的值。
1 // CountDownLatch的构造方法
2 public CountDownLatch(int count) {
3 if (count < 0) throw new IllegalArgumentException("count < 0");
4 this.sync = new Sync(count);
5 }
6 ...
7 // Sync继承自AQS
8 private static final class Sync extends AbstractQueuedSynchronizer {
9 ...
10 // Sync的构造方法
11 Sync(int count) {
12 setState(count);
13 }
14 ...
15 }
16 ...
17 // AQS类的setState()方法
18 protected final void setState(int newState) {
19 state = newState;
20 }1.2.2 await()方法
调用await()方法时，线程会阻塞，直到计数器的值变为0时，才会继续执行。
通过await()方法，判断AQS中state字段的值是否为0，若为0则不被阻塞，若不为0则阻塞入列当前线程。
1 // CountDownLatch的await()方法
2 public void await() throws InterruptedException {
3 sync.acquireSharedInterruptibly(1);
4 }
5 ...
6 // AQS的acquireSharedInterruptibly()方法
7 public final void acquireSharedInterruptibly(int arg)
8 throws InterruptedException {
9 if (Thread.interrupted())
10 throw new InterruptedException();
11 if (tryAcquireShared(arg) < 0)
12 doAcquireSharedInterruptibly(arg);
13 }
14 ...
15 // Sync的tryAcquireShared()方法
16 protected int tryAcquireShared(int acquires) {
17 return (getState() == 0) ? 1 : -1;
18 }1.2.3 countDown()方法
调用countDown()方法时，计数器数值会减1，当计数器被减为0时，唤醒被阻塞的线程。
在countDown()方法中，会对AQS中state字段的值进行双层判断：
1）在减少计数前，判断AQS中state字段的值是否为0，为0则返回false，不为0则减1并继续判断。
2）在减少计数后，判断AQS中state字段的值是否为0，为0则返回true，不为0则返回false。
只有在减少后判断等于0的时候才会唤醒等待线程，如果在减少前判断等于0则表示已经有其他线程唤醒过了，如果在减少后判断大于0则表示不能唤醒。
1 // CountDownLatch的countDown()方法
2 public void countDown() {
3 sync.releaseShared(1);
4 }
5 // AQS的releaseShared()方法
6 public final boolean releaseShared(int arg) {
7 if (tryReleaseShared(arg)) {
8 doReleaseShared();
9 return true;
10 }
11 return false;
12 }
13 // Sync的tryReleaseShared()方法
14 protected boolean tryReleaseShared(int releases) {
15 // Decrement count; signal when transition to zero
16 for (;;) {
17 int c = getState();
18 if (c == 0)
19 return false;
20 int nextc = c-1;
21 if (compareAndSetState(c, nextc))
22 return nextc == 0;
23 }
24 }1.3 使用举例
1 public static void main(String[] args) throws InterruptedException {
2 CountDownLatch cdl = new CountDownLatch(3);
3 for (int i = 0; i < cdl.getCount(); i++) {
4 new Thread(() -> {
5 System.out.println(Thread.currentThread().getName() + "离开课堂");
6 cdl.countDown();
7 }, i + "号").start();
8 }
9 cdl.await();
10 System.out.println("所有学生都已离开课堂");
11 }2 CyclicBarrier
2.1 简介
一个同步辅助类，用于将线程阻塞某段时间，等其他线程也被阻塞后，唤醒被阻塞的线程，同时由最后阻塞的线程执行指定操作。
CyclicBarrier在内部维护了一个计数器和一个屏障操作，需要在构造方法中传入一个正整数值和一个屏障方法。
在线程中通过await()方法将计数器减一，判断计数器是否等于0，如果不等于0则将线程阻塞，如果等于0则唤醒等待线程，并由当前线程执行屏障方法。
底层使用Lock用于阻塞和唤醒线程。
2.2 源码分析
2.2.1 构造方法
构造方法有两个，最终调用的是同一个。
要求传入一个整型的数量，以及一个屏障操作，当等待的线程达到指定数量时，由最后等待的线程执行屏障操作。
1 // CyclicBarrier的构造方法，指定计数器和屏障方法
2 public CyclicBarrier(int parties, Runnable barrierAction) {
3 if (parties <= 0) throw new IllegalArgumentException();
4 this.parties = parties;
5 this.count = parties;
6 this.barrierCommand = barrierAction;
7 }
8 // CyclicBarrier的构造方法，指定计数器，默认屏障方法为空
9 public CyclicBarrier(int parties) {
10 this(parties, null);
11 }2.2.2 await()方法
调用await()方法后，线程会进入等待状态，直到达到指定数量后，执行屏障操作。
1 public int await() throws InterruptedException, BrokenBarrierException {
2 try {
3 return dowait(false, 0L);
4 } catch (TimeoutException toe) {
5 throw new Error(toe); // cannot happen
6 }
7 }2.3 使用举例
1 public static void main(String[] args) {
2 CyclicBarrier cb = new CyclicBarrier(7, () -> {
3 System.out.println(Thread.currentThread().getName() + "龙珠是最后一颗，龙珠集齐，召唤神龙");
4 });
5 for (int i = 1; i <= 7; i++) {
6 new Thread(() -> {
7 try {
8 System.out.println(Thread.currentThread().getName() + "龙珠被收集");
9 cb.await();
10 } catch (Exception e) {
11 e.printStackTrace();
12 }
13 }, String.valueOf(i)).start();
14 }
15 }3 Semaphore
3.1 简介
一个同步辅助类，可以看做是一个计数信号量，信号量维护了一个许可集。
线程调用acquire()方法时，会尝试获取许可，即将信号量减一并判断是否大于等于0，获取失败则阻塞并等待，直到有信号量释放获取成功后才能继续执行。
线程调用release()方法会释放许可，将信号量加一，并唤醒被阻塞的线程。
底层使用LockSupport用于阻塞和唤醒线程。
3.2 源码分析
3.2.1 构造方法
构造方法有两个，都需要传入整型的许可数量，第一个使用非公平的锁，第二个可以传入参数指定使用公平锁还是非公平锁。
1 // Semaphore类的非公平锁的构造方法
2 public Semaphore(int permits) {
3 sync = new NonfairSync(permits);
4 }
5 // Semaphore类的公平锁的构造方法
6 public Semaphore(int permits, boolean fair) {
7 sync = fair ? new FairSync(permits) : new NonfairSync(permits);
8 }
9 ...
10 // 非公平锁和公平锁都继承自Sync，Sync继承自AQS
11 abstract static class Sync extends AbstractQueuedSynchronizer {
12 ...
13 Sync(int permits) {
14 setState(permits);
15 }
16 ...
17 }
18 ...
19 // AQS类的setState()方法
20 protected final void setState(int newState) {
21 state = newState;
22 }3.2.2 acquire()方法
调用acquire()方法会尝试获取许可，获取不到会一直阻塞。
1 public void acquire() throws InterruptedException {
2 sync.acquireSharedInterruptibly(1);
3 }3.2.3 release()方法
调用release()方法会释放许可，唤醒被阻塞的线程。
1 public void release() {
2 sync.releaseShared(1);
3 }3.3 使用举例
1 public static void main(String[] args) {
2 Semaphore s = new Semaphore(3);
3 for (int i = 1; i <= 6; i++) {
4 new Thread(() -> {
5 try {
6 s.acquire();
7 System.out.println(Thread.currentThread().getName() + "抢到了");
8 Thread.sleep(100 * new Random().nextInt(5));
9 } catch (InterruptedException e) {
10 e.printStackTrace();
11 } finally {
12 System.out.println(Thread.currentThread().getName() + "释放了");
13 s.release();
14 }
15 }, String.valueOf(i)).start();
16 }
17 }
