public class CountDownLatch {
    /**
     * 首先CountDownLatch和其他锁机制一样实现了队列同步器AQS，通过他的setState、getCount、和tryxxx方法实现同步操作
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

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

        int getCount() {
            return getState();
        }
//共享式的获取同步状态，如果count为0就获取锁
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
//共享式的释放锁
        protected boolean tryReleaseShared(int releases) {
            // count减1，直达count为0
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
              //compareAndSetState保证了原子操作
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

    private final Sync sync;

    /**
     *构造器需要接收一个int类型的参数作为计数器，不能为负数
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    /**
     * 使当前线程阻塞，直到count为0才继续执行
     */
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 在指定的时间内count还没为0，当前线程继续执行
     */
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 使count-1
     */
    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() {
        return sync.getCount();
    }

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

 public class CyclicBarrier {
   //内部使用重入锁
   ……
   //parties指屏障的线程数，barrierAction在线程到达屏障时，优先执行
    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }
   //一个参数的构造方法
    public CyclicBarrier(int parties) {
        this(parties, null);
    }
   //用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；也有传入限制时间的await
   public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }
   //用于重置计数器，如果有正在被屏障的线程，则会抛出BrokenBarrierException异常
   public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier();   // break the current generation
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
    }
   // 查看被屏障的线程是否被中断
   public boolean isBroken() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return generation.broken;
        } finally {
            lock.unlock();
        }
    }
 }