Java中的CountDownLatch源码解析

 public class CountDownLatch {
        //内部类Sync继承了AQS
        private static final class Sync extends AbstractQueuedSynchronizer {
            private static final long serialVersionUID = 4982264981922014374L;
            //构造方法中的count其实就是传给了AQS的state属性
            Sync(int count) {
                setState(count);
            }
            //得到的AQS的state属性值
            int getCount() {
                return getState();
            }
            //重写的AQS的tryAcquireShared，在共享模式的情况下获取锁
            protected int tryAcquireShared(int acquires) {
                //获取锁的前提是state为0，表示当前未被其他线程占有
                return (getState() == 0) ? 1 : -1;
            }
            //重写的AQS的tryReleaseShared，在共享模式下释放锁
            protected boolean tryReleaseShared(int releases) {
                // 减count; 当count为0时唤醒
                for (;;) {
                    int c = getState();
                    if (c == 0)  //表示释放锁的前提是占有锁，也就是state的属性值大于0
                        return false;
                    int nextc = c-1;  //state的值减1
                    if (compareAndSetState(c, nextc))  //利用CAS来改变state的值
                        return nextc == 0;  //当state的值为0时返回true
                }
            }
        }
        private final Sync sync;
        /**
         * 通过count初始化一个CountDownLatch
         *
         *在线程调用await方法后如果想通过，必须执行count次countDown方法
         * @如果count为负数，则抛出IllegalArgumentException
         */
        public CountDownLatch(int count) {
            if (count < 0) throw new IllegalArgumentException("count < 0");
            this.sync = new Sync(count);
        }
    ================================================================================================
    				两个核心方法，其实底层使用的AQS的方法（共享模式下）
        /**
         * 调用await方法会使当前的线程等待除非count的数值降为0或者中间抛出异常
         *
         * 如果当前的count为0，则该方法立即返回
         *
         *如果当前的count大于0，则当前线程因线程调度目的而被禁用，并且休眠，直到发生以下两种情况之一：
         *1、调用countDown方法将count的值降为0
         *2、其他的线程打断了当前线程，使用Thread.interrupted
         */
        public void await() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
        /**
         *减count的值，如果count的值为0了，则释放所有等待的线程
         *
         *如果当前的count值大于0，那么它是被减了。
         *如果当前的count值等于0，那么所有等待的线程被唤醒接受线程的调度
         */
        public void countDown() {
            sync.releaseShared(1);
        }
    ================================================================================================
        /**
    	 *返回count的值，用于调试或者测试
         */
        public long getCount() {
            return sync.getCount();
        }

public static void main(String[] args) throws Exception{
        CountDownLatch cd = new CountDownLatch(3);
        Thread beginGame = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    cd.await();
                    System.out.println("欢迎来到王者荣耀，敌军还有30秒到达战场============");
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        },"beginGame");
        Thread player1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("玩家一以准备=======");
                    cd.countDown();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        },"player1");
        Thread player2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    System.out.println("玩家二以准备=======");
                    cd.countDown();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        },"player2");
        beginGame.start();
        player1.start();
        player2.start();
    }