public class CountDownLatch {
  /**
   * CountDownLatch 實(shí)現(xiàn)同步控制
   * 底層是使用AQS的state來(lái)代表count
   */
  private static final class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 4982264981922014374L;
    //初始化內(nèi)部類(lèi)實(shí)際上是設(shè)置AQS的state
    Sync(int count) {
      setState(count);
    }

    int getCount() {
      return getState();
    }
    //嘗試獲取共享是看當(dāng)前的state是否為0
    protected int tryAcquireShared(int acquires) {
      return (getState() == 0) ? 1 : -1;
    }
    /*嘗試釋放共享鎖則是遞減計(jì)數(shù)直到state==0就返回false代表資源已經(jīng)釋放完全否則就會(huì)使用CAS來(lái)讓state減一*/
    protected boolean tryReleaseShared(int releases) {
      
      for (;;) {
        int c = getState();
        if (c == 0)
          return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
          return nextc == 0;
      }
    }
  }

  private final Sync sync;

  /**
   * 初始化CountDownLatch，實(shí)際上是初始化內(nèi)部類(lèi)，實(shí)際上是設(shè)置AQS的state，count不能小于0
   */
  public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
  }

  /**
   * 這里實(shí)際上是調(diào)用了AQS里的acquireSharedInterruptibly方法，完成的功能就是先去查看線程是否被中斷，中斷則拋出異常，沒(méi)有被中斷就會(huì)嘗試獲取共享資源。   * 注意在syn內(nèi)部類(lèi)中重寫(xiě)了tryAcquireShared，也就是當(dāng)state為0就返回1，這時(shí)候就會(huì)將當(dāng)前線程放入AQS的隊(duì)列中去，也就是這時(shí)候線程可以不再阻塞而是嘗試去獲取鎖
   */
  public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }

  /**
   * 原理同上面方法，但是加了一個(gè)時(shí)間參數(shù)來(lái)設(shè)置等待的時(shí)間
   */
  public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
  }

  /**
   * 這里傳入?yún)?shù)為1，同樣上面內(nèi)部類(lèi)一樣重寫(xiě)了AQS的tryReleaseShared方法，使用這個(gè)重寫(xiě)的方法來(lái)讓計(jì)數(shù)器原子操作的減一
   */
  public void countDown() {
    sync.releaseShared(1);
  }

  /**
   * 就是獲取AQS的state
   */
  public long getCount() {
    return sync.getCount();
  }

  /**
   * 轉(zhuǎn)換成字符串的方法
   */
  public String toString() {
    return super.toString() + "[Count = " + sync.getCount() + "]";
  }
}

public class Semaphore implements java.io.Serializable {  private static final long serialVersionUID = -3222578661600680210L;  /** 所有機(jī)制都通過(guò)AbstractQueuedSynchronizer子類(lèi)實(shí)現(xiàn) */
  private final Sync sync;

  /**
   * 同樣是通過(guò)內(nèi)部類(lèi)來(lái)實(shí)現(xiàn)AQS主要功能，使用state來(lái)表示許可證數(shù)量
   */
  abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;

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

    final int getPermits() {
      return getState();
    }
    /*
    * 不公平的獲取方式，會(huì)有一個(gè)搶占鎖的情況，即線程執(zhí)行順序會(huì)亂
    */
    final int nonfairTryAcquireShared(int acquires) {
      for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
          compareAndSetState(available, remaining))
          return remaining;
      }
    }
    /*
    * 釋放資源
    */  
    protected final boolean tryReleaseShared(int releases) {
      for (;;) {
        int current = getState();
        int next = current + releases;
        if (next < current) // overflow
          throw new Error("Maximum permit count exceeded");
        if (compareAndSetState(current, next))
          return true;
      }
    }

    final void reducePermits(int reductions) {
      for (;;) {
        int current = getState();
        int next = current - reductions;
        if (next > current) // underflow
          throw new Error("Permit count underflow");
        if (compareAndSetState(current, next))
          return;
      }
    }

    final int drainPermits() {
      for (;;) {
        int current = getState();
        if (current == 0 || compareAndSetState(current, 0))
          return current;
      }
    }
  }

  /**
   * 不公平的sync版本，使用的就是sync定義的不公平鎖
   */
  static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;

    NonfairSync(int permits) {
      super(permits);
    }

    protected int tryAcquireShared(int acquires) {
      return nonfairTryAcquireShared(acquires);
    }
  }

  /**
   * 公平版本，獲取鎖的線程順序就是線程啟動(dòng)的順序。具體是使用hasQueuedPredecessors()方法判斷“當(dāng)前線程”是不是CLH隊(duì)列中的第一個(gè)線程。   * 若不是的話，則返回-1，是就設(shè)置獲取許可證，并檢查許可證數(shù)量是否足夠
   */
  static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;

    FairSync(int permits) {
      super(permits);
    }

    protected int tryAcquireShared(int acquires) {
      for (;;) {
        if (hasQueuedPredecessors())
          return -1;
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
          compareAndSetState(available, remaining))
          return remaining;
      }
    }
  }

  /**
   * 默認(rèn)使用不公平的版本，如果需要公平的，則需要兩個(gè)參數(shù)
   */
  public Semaphore(int permits) {
    sync = new NonfairSync(permits);
  }

  
  public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
  }

  /**
   * 分析同CountDownLatch中的類(lèi)似方法，具體的實(shí)現(xiàn)都是內(nèi)部類(lèi)中的獲取方法，這里是獲取一個(gè)許可
   */
  public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }

  /**
   *功能同上，但是這里不會(huì)檢測(cè)線程是否被中斷
   */
  public void acquireUninterruptibly() {
    sync.acquireShared(1);
  }

  /**
   * 嘗試獲取
   */
  public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
  }

  /**
   * 在一段時(shí)間內(nèi)一直嘗試獲取許可
   */
  public boolean tryAcquire(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
  }

  /**
   * 當(dāng)前線程釋放一個(gè)許可證
   */
  public void release() {
    sync.releaseShared(1);
  }

  /**
   * 可以規(guī)定一個(gè)線程獲得許可證的數(shù)量
   */
  public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
  }

  public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
  }

  public boolean tryAcquire(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
  }

  public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
    throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
  }

  /**
   * 同樣可以規(guī)定一個(gè)線程釋放許可證的數(shù)量
   */
  public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
  }

  /**
   * 當(dāng)前的許可還剩幾個(gè)
   */
  public int availablePermits() {
    return sync.getPermits();
  }

  /**
   * 銷(xiāo)毀所有許可
   */
  public int drainPermits() {
    return sync.drainPermits();
  }

  protected void reducePermits(int reduction) {
    if (reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
  }

  public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
  }

  public final int getQueueLength() {
    return sync.getQueueLength();
  }

  protected Collection<Thread> getQueuedThreads() {
    return sync.getQueuedThreads();
  }
  public String toString() {
    return super.toString() + "[Permits = " + sync.getPermits() + "]";
  }}

public class ReentrantLock implements Lock, java.io.Serializable {
  private static final long serialVersionUID = 7373984872572414699L;
  /** 同步的機(jī)制都是通過(guò)內(nèi)部類(lèi)來(lái)實(shí)現(xiàn)的 */
  private final Sync sync;

  /**
   * 在ReentrantLock中state表示的是線程重入鎖的次數(shù)，當(dāng)state為0時(shí)才能釋放鎖
   */
  abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

    /**
     * 這個(gè)抽象方法提供給公平鎖和不公平鎖來(lái)單獨(dú)實(shí)現(xiàn)，父類(lèi)不實(shí)現(xiàn)
     */
    abstract void lock();

    /**
     * 首先得到當(dāng)前線程，而后獲取state，如果state為0，也就是沒(méi)有線程獲得當(dāng)前鎖，那么就設(shè)置當(dāng)前線程擁有當(dāng)前鎖的獨(dú)占訪問(wèn)權(quán)，并且返回true。     * 如果state不為0，那么就看當(dāng)前線程是否是已經(jīng)獲得過(guò)鎖的線程，如果是就讓state+=acquire，acquire一般是1，即表示線程重入并且返回true。     * 上面兩個(gè)條件都不滿足就代表是鎖被其他線程獲取了，當(dāng)前線程獲取不到，所以返回false
     */
    final boolean nonfairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
        if (compareAndSetState(0, acquires)) {
          setExclusiveOwnerThread(current);
          return true;
        }
      }
      else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
          throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
      }
      return false;
    }
    /**
     * 先判斷當(dāng)前線程等不等于擁有鎖的線程，不等于就會(huì)拋異常，也就是釋放不了。     * 等于之后就看state-releases是否為0，當(dāng)為0的時(shí)候就代表釋放完全。     * 可以設(shè)置鎖的狀態(tài)為沒(méi)有線程擁有，從而讓鎖能被其他線程競(jìng)爭(zhēng)，否則就設(shè)置state，代表線程重入該鎖，并且線程還沒(méi)釋放完全。
     */
    protected final boolean tryRelease(int releases) {
      int c = getState() - releases;
      if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
      boolean free = false;
      if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
      }
      setState(c);
      return free;
    }
    /*
     *該方法檢驗(yàn)當(dāng)前線程是否是鎖的獨(dú)占者
     */
    protected final boolean isHeldExclusively() {
      return getExclusiveOwnerThread() == Thread.currentThread();
    }
    /*
     *該方法是創(chuàng)建一個(gè)條件鎖，本文不做具體分析
     */
    final ConditionObject newCondition() {
      return new ConditionObject();
    }

    // Methods relayed from outer class

    final Thread getOwner() {
      return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    final int getHoldCount() {
      return isHeldExclusively() ? getState() : 0;
    }

    final boolean isLocked() {
      return getState() != 0;
    }

    /**
     * 使得該類(lèi)從流中能重構(gòu)實(shí)例，并且會(huì)重置為解鎖狀態(tài)
     */
    private void readObject(java.io.ObjectInputStream s)
      throws java.io.IOException, ClassNotFoundException {
      s.defaultReadObject();
      setState(0); 
    }
  }

  /**
   * Sync 的不公平版本
   */
  static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * 將state從0更新到1成功的話就讓當(dāng)前線程獲取鎖，否則就會(huì)嘗試獲得鎖和獲取當(dāng)前節(jié)點(diǎn)的前一節(jié)點(diǎn)，并判斷這一個(gè)節(jié)點(diǎn)是否為頭節(jié)點(diǎn)，即當(dāng)前線程是不是頭節(jié)點(diǎn)的直接后繼。     * 如果兩個(gè)中有一個(gè)失敗則線程中斷，進(jìn)入阻塞狀態(tài)
     */
    final void lock() {
      if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
      else
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
      return nonfairTryAcquire(acquires);
    }
  }

  /**
   * Sync 的公平版本
   */
  static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    /**
    * 嘗試獲得鎖和獲取當(dāng)前節(jié)點(diǎn)的前一節(jié)點(diǎn)，并判斷這一個(gè)節(jié)點(diǎn)是否為頭節(jié)點(diǎn)，即當(dāng)前線程是不是頭節(jié)點(diǎn)的直接后繼，如果兩個(gè)中有一個(gè)失敗則線程中斷，進(jìn)入阻塞狀態(tài)。    * 也就是一定按照隊(duì)列中線程的順序來(lái)實(shí)現(xiàn)
    */
    final void lock() {
      acquire(1);
    }

    /**
     * 跟不公平的版本相比其實(shí)是在state為0的時(shí)候檢查當(dāng)前線程是不是在隊(duì)列的頭部節(jié)點(diǎn)的直接后繼，來(lái)達(dá)到公平的概念
     */
    protected final boolean tryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
      int c = getState();
      if (c == 0) {
        if (!hasQueuedPredecessors() &&
          compareAndSetState(0, acquires)) {
          setExclusiveOwnerThread(current);
          return true;
        }
      }
      else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
          throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
      }
      return false;
    }
  }
}