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 }