CountDownLatch（闭锁）--实现

1.介绍

   基于AQS实现同步器, CountDownLatch 用同步状态持有当前计数，

   countDown方法调用 release从而导致计数器递减；

   当计数器为0时，解除所有线程的等待；

   await调用acquire，如果计数器为0，acquire 会立即返回，否则阻塞。

   通常用于某任务需要等待其他任务都完成后才能继续执行的情景。

 

2.源码实现

   public class CountDownLatch {

     /**
      * Synchronization control For CountDownLatch.
      * Uses AQS state to represent 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;

     /**
      * Constructs a {@code CountDownLatch} initialized with the given count.
      *
      * @param count the number of times {@link #countDown} must be invoked
      *        before threads can pass through {@link #await}
      * @throws IllegalArgumentException if {@code count} is negative
      */
     public CountDownLatch(int count) {
         if (count < 0) throw new IllegalArgumentException("count < 0");
         this.sync = new Sync(count);
     }
     public void await() throws InterruptedException {
         sync.acquireSharedInterruptibly(1);
     }

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

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

     /**
      * Returns the current count.
      *
      * <p>This method is typically used for debugging and testing purposes.
      *
      * @return the current count
      */
     public long getCount() {
         return sync.getCount();
     }

     /**
      * Returns a string identifying this latch, as well as its state.
      * The state, in brackets, includes the String {@code "Count ="}
      * followed by the current count.
      *
      * @return a string identifying this latch, as well as its state
      */
     public String toString() {
         return super.toString() + "[Count = " + sync.getCount() + "]";
       }
    }

 }

 

看完源码可以在看看队列

 

 

 

学习来源：https://www.cnblogs.com/wushenghfut/p/11258767.html