JDK之CountDownLatch

离家乡还是很远

1. 内部类

private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

        Sync(int count) {
            setState(count);
        }

        int getCount() {
            return getState();
        }

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

        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

• 方法都比较简单，tryReleaseShared每次释放一把共享锁

2. 成员变量

private final Sync sync;

• 一个Sync实例用以实现具体功能

3. 构造器

 public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

• 相当于在一开始构造的时候，给Sync实例加了count层共享锁

---

思考：为什么要加共享锁？加排他锁可以吗？

从语义上考虑，锁的释放必须由锁的持有线程进行操作，排它锁只有一个持有线程，而共享锁可能是多个线程持有，所以这里共享锁更符合语义。

从实现上考虑，锁的释放必须由锁的持有线程进行操作这个条件在AQS中是没有做判断的，需要由AQS的实现类自己完成。比如在可重入锁中，排它锁的释放代码中会首先判断锁的持有线程是否是当前线程。所以，共享锁与排它锁的具体取别还是得根据自己实现的代码来判断，我们确实也可以用排它锁来实现CountDownLatch，只需要改改方法名就可以

4. await方法

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

• await的处理逻辑是如果仍有锁存在，那么await的线程就会添加到等待队列，等待被唤醒

5. countDown方法

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

• 就是释放一把共享锁

6. 其余方法

// 获取剩余锁的数量
public long getCount() {
        return sync.getCount();
    }

public String toString() {
        return super.toString() + "[Count = " + sync.getCount() + "]";
    }