CountDownLatch源码分析

package java.util.concurrent;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

public class CountDownLatch {
	
    /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.	
	 * 
	 * 用AbstractQueuedSynchronizer的状态来表示count。
     */
    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;
            }
        }
    }

    private final Sync sync;

	
	// 构造一个等待线程数量为count的闭锁。	注：count的值一旦设定就不可以更改了。
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

    /**
     * Causes the current thread to wait until the latch has counted down to zero, unless the thread is interrupted.
     *
     * If the current count is greater than zero then the current thread becomes disabled for thread scheduling purposes 
	 * and lies dormant until one of two things happen:
     * 		The count reaches zero due to invocations of the {@link #countDown} method;
     * 		Some other thread {@linkplain Thread#interrupt interrupts} the current thread.
     */
	// 线程调用await()方法，进入等待状态。
    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }
	// -------------------- 补充：AbstractQueuedSynchronizer 中的方法 ----------------------------------------
	//
	//		public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
	//			if (Thread.interrupted())
	//				throw new InterruptedException();
	//			if (tryAcquireShared(arg) < 0) // 获取锁失败
	//				doAcquireSharedInterruptibly(arg);
	//		}
	//
	//		private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
	//	            final Node node = addWaiter(Node.SHARED);
	//	            boolean failed = true;
	//	            try {
	//	                for (;;) {				// 开始自旋
	//	                    final Node p = node.predecessor();
	//	                    if (p == head) {
	//	                        int r = tryAcquireShared(arg);
	//	                        if (r >= 0) {
	//	                            setHeadAndPropagate(node, r);
	//	                            p.next = null; // help GC
	//	                            failed = false;
	//	                            return;
	//	                        }
	//	                    }
	//	                    if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
	//	                        throw new InterruptedException();
	//	                }
	//	            } finally {
	//	                if (failed) cancelAcquire(node);
	//	            }
	//	    }
	//
	// -------------------- 补充：AbstractQueuedSynchronizer 中的方法 ----------------------------------------

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

    /**
     * Decrements the count of the latch, releasing all waiting threads if the count reaches zero.
     * If the current count equals zero then nothing happens.
     */
    public void countDown() {
        sync.releaseShared(1);
    }
	// -------------------- 补充：AbstractQueuedSynchronizer 中的方法 ----------------------------------------
	//
	//	    public final boolean releaseShared(int arg) {
	//	        if (tryReleaseShared(arg)) {
	//	            doReleaseShared();
	//	            return true;
	//	        }
	//	        return false;
	//	    }
	//
	//	    private void doReleaseShared() {
	//	        /*
	//	         * Ensure that a release propagates, even if there are other
	//	         * in-progress acquires/releases.  This proceeds in the usual
	//	         * way of trying to unparkSuccessor of head if it needs
	//	         * signal. But if it does not, status is set to PROPAGATE to
	//	         * ensure that upon release, propagation continues.
	//	         * Additionally, we must loop in case a new node is added
	//	         * while we are doing this. Also, unlike other uses of
	//	         * unparkSuccessor, we need to know if CAS to reset status
	//	         * fails, if so rechecking.
	//	         */
	//	        for (;;) {
	//	            Node h = head;
	//	            if (h != null && h != tail) {
	//	                int ws = h.waitStatus;
	//	                if (ws == Node.SIGNAL) {
	//	                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
	//	                        continue;            // loop to recheck cases
	//	                    unparkSuccessor(h);
	//	                }
	//	                else if (ws == 0 &&
	//	                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
	//	                    continue;                // loop on failed CAS
	//	            }
	//	            if (h == head)                   // loop if head changed
	//	                break;
	//	        }
	//	    }
	//
	// -------------------- 补充：AbstractQueuedSynchronizer 中的方法 ----------------------------------------

    /**
     * Returns the current count.
     */
    public long getCount() {
        return sync.getCount();
    }

}