public interface Lock {
    // 獲取鎖。如果鎖不可用，則當前線程將出于線程調(diào)度目的而禁用，并處于休眠狀態(tài)，直到獲得鎖為止。
    void lock();
    // 如果當前線程未被中斷，則獲取鎖。如果鎖可用，則獲取鎖并立即返回。
    // 如果鎖不可用，出于線程調(diào)度目的，將禁用當前線程，該線程將一直處于休眠狀態(tài)。
    // 下面兩種情形會讓當前線程停止休眠狀態(tài)：
    // 1.鎖由當前線程獲取。
    // 2.其他一些線程中斷當前線程，并且支持對鎖獲取的中斷。
    // 當前線程出現(xiàn)下面兩種情況時，將拋出InterruptedException，并清除當前線程的中斷狀態(tài)。
    // 1.當前線程在進入此方法時，已經(jīng)設置為中斷狀態(tài)。
    // 2. 當前線程在獲取鎖時被中斷，并且支持對鎖獲取中斷。
    void lockInterruptibly() throws InterruptedException;
    // 嘗試獲取鎖，如果鎖處于空閑狀態(tài)，則獲取鎖，并立即返回true。如果鎖不可用，則立即返回false。
    // 典型用法：
    // 確保解鎖前一定獲取到鎖
    // if (lock.tryLock()) {
    //     try {
    //             // manipulate protected state
    //     } finally {
    //          lock.unlock();
    //     }
    // } else {
    //     // perform alternative actions
    // }
    boolean tryLock();
    // 該方法為tryLock()的重載方法，兩個參數(shù)分別表示為：
    // time：等待鎖的最長時間
    // unit：時間單位
    // 如果在給定的等待時間內(nèi)是空閑的并且當前線程沒有被中斷，則獲取鎖。如果鎖可用，則此方法立即獲取鎖并返回true，如果鎖不可用，出于線程調(diào)度目的，將禁用當前線程，該線程將一直處于休眠狀態(tài)。
    // 如果指定的等待時間超時，則返回false值。如果時間小于或等于0，則該方法永遠不會等待。
    // 下面三種情形會讓當前線程停止休眠狀態(tài)：
    // 1.鎖由當前線程獲取。
    // 2.其他一些線程中斷當前線程，并且支持對鎖獲取的中斷。
    // 3.到了指定的等待時間。
    // 當前線程出現(xiàn)下面兩種情況時，將拋出InterruptedException，并清除當前線程的中斷狀態(tài)。
    // 1.當前線程在進入此方法時，已經(jīng)設置為中斷狀態(tài)。
    // 2.當前線程在獲取鎖時被中斷，并且支持對鎖獲取中斷。
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    // 釋放鎖，與lock()、tryLock()、tryLock(long , TimeUnit)、lockInterruptibly()相對應。
    void unlock();
    // 返回綁定到此鎖實例的Condition實例。當前線程只有獲得了鎖，才能調(diào)用Condition實例的方法。
    Condition newCondition();
}

// 無參構造方法
// 默認是非公平鎖模式
public ReentrantLock() {
    sync = new NonfairSync();
}
// 有參構造方法
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

static abstract class Sync extends AbstractQueuedSynchronizer {
abstract void lock();
// 非公平獲取, 非公平鎖都需要這個方法
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {   
        // state == 0表示無鎖
        // 通過CAS的方式競爭鎖，體現(xiàn)非公平性，任何線程來了不用排隊都可以搶鎖
        if (compareAndSetState(0, acquires)) {  
            // 加鎖成功，state狀態(tài)改為1
            // 當前哪一個線程獲取到鎖，將線程信息記錄到AQS里面
            // 設置當前持有鎖的線程
            setExclusiveOwnerThread(current);   
            return true;                      
        }
    } else if (current == getExclusiveOwnerThread()) {
            // 當前線程正是鎖持有者，此段邏輯體現(xiàn)可重入性
            // 同一個線程可以在不獲取鎖的情況再次進入
            // nextc表示被加鎖次數(shù)，即重入次數(shù)
            int nextc = c + acquires;
            if (nextc < 0) // 被鎖次數(shù)上溢(很少出現(xiàn))
                throw new Error("Maximum lock count exceeded");
            // 設置加鎖次數(shù)，lock幾次就要unlock幾次，否則無法釋放鎖
            setState(nextc);
            return true;
        }
        return false;
    }
    // 釋放
    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;
    }
    // 當前線程是否持有鎖
    protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
    final ConditionObject newCondition() {
        return new ConditionObject();
    }
    // 鎖的持有者
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }
    // 加鎖次數(shù)
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }
    // 是否上鎖,根據(jù)state字段可以判斷
    final boolean isLocked() {
        return getState() != 0;
    }
}

static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        final void lock() {
            acquire(1);
        }
        // 方法邏輯與Snyc中的nonfairTryAcquire方法一致，只是加了線程排隊的邏輯
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                // !hasQueuedPredecessors()
                // 判斷隊列中是否有其他線程，沒有才進行鎖的獲取，否則繼續(xù)排隊
                // 體現(xiàn)公平性
                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;
        }
    }

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;
        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            // 不管鎖是否已經(jīng)被占用，采用CAS的方式進行鎖競爭
            // 搶鎖成功，則把當前線程設置為活躍的線程
            // 搶鎖失敗則走acquire(1)邏輯
            // 體現(xiàn)非公平性，線程不必排隊
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                // 搶鎖失敗，調(diào)用tryAcquire方法，最終調(diào)用nonfairTryAcquire方法
                acquire(1);
        }
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    // 返回綁定到此鎖實例的Condition實例。當前線程只有獲得了鎖，才能調(diào)用Condition實例的方法。
    Condition newCondition();

public interface Condition {
    // 線程程進入等待狀態(tài)直到被通知(signal)或中斷
    // 當其他線程調(diào)用singal()或singalAll()方法時，該線程將被喚醒
    // 當其他線程調(diào)用interrupt()方法中斷當前線程
    // await()相當于synchronized等待喚醒機制中的wait()方法
    void await() throws InterruptedException;
    // 與wait()方法相同，唯一的不同點是，該方法不會再等待的過程中響應中斷
    void awaitUninterruptibly();
    // 當前線程進入等待狀態(tài)，直到被喚醒或被中斷或超時
    // 其中nanosTimeout指的等待超時時間，單位納秒
    long awaitNanos(long nanosTimeout) throws InterruptedException;
    // 同awaitNanos，但可以指明時間單位
    boolean await(long time, TimeUnit unit) throws InterruptedException;
    // 線程進入等待狀態(tài)，直到被喚醒、中斷或到達某個時
    // 間期限(deadline),如果沒到指定時間就被喚醒，返回true，其他情況返回false
    boolean awaitUntil(Date deadline) throws InterruptedException;
    // 喚醒一個等待在Condition上的線程，該線程從等待方法返回前必須
    // 獲取與Condition相關聯(lián)的鎖，功能與notify()相同
    void signal();
    // 喚醒所有等待在Condition上的線程，該線程從等待方法返回前必須
    // 獲取與Condition相關聯(lián)的鎖，功能與notifyAll()相同
    void signalAll();
}

public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;
        /** First node of condition queue. */
        // 等待隊列第一個等待結點
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        // 等待隊列最后一個等待結點
        private transient Node lastWaiter;
        /**
         * Creates a new {@code ConditionObject} instance.
         */
        public ConditionObject() { }
}

public final void await() throws InterruptedException {
      // 判斷線程是否被中斷
      if (Thread.interrupted())
          throw new InterruptedException();
      // 創(chuàng)建新結點加入等待隊列并返回
      Node node = addConditionWaiter();
      // 釋放當前線程鎖即釋放同步狀態(tài)
      int savedState = fullyRelease(node);
      int interruptMode = 0;
      // 判斷結點是否同步隊列(SyncQueue)中,即是否被喚醒
      while (!isOnSyncQueue(node)) {
          // 掛起線程
          LockSupport.park(this);
          // 判斷是否被中斷喚醒，如果是退出循環(huán)。
          if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
              break;
      }
      // 被喚醒后執(zhí)行自旋操作爭取獲得鎖，同時判斷線程是否被中斷
      if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
          interruptMode = REINTERRUPT;
       // clean up if cancelled
      if (node.nextWaiter != null) 
          // 清理等待隊列中不為CONDITION狀態(tài)的結點
          unlinkCancelledWaiters();
      if (interruptMode != 0)
          reportInterruptAfterWait(interruptMode);
  }
private Node addConditionWaiter() {
    Node t = lastWaiter;
      // 判斷是否為結束狀態(tài)的結點并移除
      if (t != null && t.waitStatus != Node.CONDITION) {
          unlinkCancelledWaiters();
          t = lastWaiter;
      }
      // 創(chuàng)建新結點狀態(tài)為CONDITION
      Node node = new Node(Thread.currentThread(), Node.CONDITION);
      // 加入等待隊列
      if (t == null)
          firstWaiter = node;
      else
          t.nextWaiter = node;
      lastWaiter = node;
      return node;
}

 public final void signal() {
   // 判斷是否持有獨占鎖，如果不是拋出異常
   // 從這點也可以看出只有獨占模式先采用等待隊列，而共享模式下是沒有等待隊列的，也就沒法使用Condition
   if (!isHeldExclusively())
          throw new IllegalMonitorStateException();
      Node first = firstWaiter;
      // 喚醒等待隊列第一個結點的線程
      if (first != null)
          doSignal(first);
 }
 private void doSignal(Node first) {
     do {
             // 移除條件等待隊列中的第一個結點，
             // 如果后繼結點為null，那么說沒有其他結點將尾結點也設置為null
            if ( (firstWaiter = first.nextWaiter) == null)
                 lastWaiter = null;
             first.nextWaiter = null;
          // 如果被通知節(jié)點沒有進入到同步隊列并且條件等待隊列還有不為空的節(jié)點，則繼續(xù)循環(huán)通知后續(xù)結點
         } while (!transferForSignal(first) &&
                  (first = firstWaiter) != null);
        }
// transferForSignal方法
final boolean transferForSignal(Node node) {
    // 嘗試設置喚醒結點的waitStatus為0，即初始化狀態(tài)
    // 如果設置失敗，說明當期結點node的waitStatus已不為
    // CONDITION狀態(tài)，那么只能是結束狀態(tài)了，因此返回false
    // 返回doSignal()方法中繼續(xù)喚醒其他結點的線程，注意這里并
    // 不涉及并發(fā)問題，所以CAS操作失敗只可能是預期值不為CONDITION，
    // 而不是多線程設置導致預期值變化，畢竟操作該方法的線程是持有鎖的。
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
         return false;
        // 加入同步隊列并返回前驅(qū)結點p
        Node p = enq(node);
        int ws = p.waitStatus;
        // 判斷前驅(qū)結點是否為結束結點(CANCELLED=1)或者在設置
        // 前驅(qū)節(jié)點狀態(tài)為Node.SIGNAL狀態(tài)失敗時，喚醒被通知節(jié)點代表的線程
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            // 喚醒node結點的線程
            LockSupport.unpark(node.thread);
        return true;
    }

public class ABCThread implements Runnable {
    private ReentrantLock lock;
    private Condition sCondition;
    private Condition aCondition;
    public ABCThread(ReentrantLock lock, Condition sCondition, Condition aCondition) {
        this.lock = lock;
        this.sCondition = sCondition; // 喚醒下一個線程
        this.aCondition = aCondition; // 阻塞當前線程
    }
    @Override
    public void run() {
        int i = 0;
        while (i < 10) {
            // 加鎖
            lock.lock();
            try {
                // 接收到線程通知則繼續(xù)執(zhí)行，否則就阻塞
                aCondition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print(Thread.currentThread().getName()+" ");
            // 喚醒其他線程線程
            sCondition.signal();
            i++;
            // 釋放鎖
            lock.unlock();
        }
    }
}
        ReentrantLock reentrantLock = new ReentrantLock();
        Condition ab = reentrantLock.newCondition();
        Condition bc = reentrantLock.newCondition();
        Condition ca = reentrantLock.newCondition();
        new Thread(new ABCThread(reentrantLock,ab,ca),"A").start();
        new Thread(new ABCThread(reentrantLock,bc,ab),"B").start();
        new Thread(new ABCThread(reentrantLock,ca,bc),"C").start();
        reentrantLock.lock();
        ca.signal();
        reentrantLock.unlock();