//默認非公平鎖
public ReentrantLock() {
    sync = new NonfairSync();
}
//公平鎖
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

private volatile int state;

static final class Node {
      // 標識當前節(jié)點在共享模式
      static final Node SHARED = new Node();
      // 標識當前節(jié)點在獨占模式
      static final Node EXCLUSIVE = null;
      static final int CANCELLED =  1;
      static final int SIGNAL    = -1;
      static final int CONDITION = -2;
      static final int PROPAGATE = -3;
　　　 volatile int waitStatus;
      //前驅(qū)節(jié)點
      volatile Node prev;
      //后驅(qū)節(jié)點
      volatile Node next;
      //當前線程
      volatile Thread thread;
      //存儲在condition隊列中的后繼節(jié)點
      Node nextWaiter;
      //是否為共享鎖
      final boolean isShared() {
            return nextWaiter == SHARED;
      }
      final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
      }
      Node() {}
      Node(Thread thread, Node mode) {
            this.nextWaiter = mode;
            this.thread = thread;
      }
      Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
      }
}

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    private Node addWaiter(Node mode) {
        //創(chuàng)建一個節(jié)點，此處mode是獨占式的
        Node node = new Node(mode);
        for (;;) {
            Node oldTail = tail;
            if (oldTail != null) {
                // 如果tail節(jié)點非空，就將新節(jié)點的前節(jié)點設置為tail節(jié)點，并將tail指向新節(jié)點
                node.setPrevRelaxed(oldTail);
                //CAS將tail更新為新節(jié)點
                if (compareAndSetTail(oldTail, node)) {
                    //把原tail的next設為當前節(jié)點
                    oldTail.next = node;
                    return node;
                }
            } else {
                //還沒有初始化，就調(diào)用initializeSyncQueue()方法初始化
                initializeSyncQueue();
            }
        }
    }

/**
 * 已經(jīng)入隊的線程嘗試獲取鎖
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true; //標記是否成功獲取鎖
    try {
        boolean interrupted = false; //標記線程是否被中斷過
        for (;;) {
            final Node p = node.predecessor(); //獲取前驅(qū)節(jié)點
            //如果前驅(qū)是head,即該結點是第二位，有資格去嘗試獲取鎖
            if (p == head && tryAcquire(arg)) {
                setHead(node); // 獲取成功,將當前節(jié)點設置為head節(jié)點
                p.next = null; // 原h(huán)ead節(jié)點出隊
                failed = false; //獲取成功
                return interrupted; //返回是否被中斷過
            }
            // 判斷獲取失敗后是否可以掛起,若可以則掛起
            if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                // 線程若被中斷,設置interrupted為true
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

/**
 * 判斷當前線程獲取鎖失敗之后是否需要掛起.
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //前驅(qū)節(jié)點的狀態(tài)
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 前驅(qū)節(jié)點狀態(tài)為signal,返回true
        return true;
    // 前驅(qū)節(jié)點狀態(tài)為CANCELLED
    if (ws > 0) {
        // 從隊尾向前尋找第一個狀態(tài)不為CANCELLED的節(jié)點
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 將前驅(qū)節(jié)點的狀態(tài)設置為SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
/**
 * 掛起當前線程,返回線程中斷狀態(tài)并重置
 */
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

/**
 * 釋放當前線程占用的鎖
 * @param releases
 * @return 是否釋放成功
 */
protected final boolean tryRelease(int releases) {
    // 計算釋放后state值
    int c = getState() - releases;
    // 如果不是當前線程占用鎖,那么拋出異常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {
        // 鎖被重入次數(shù)為0,表示釋放成功
        free = true;
        // 清空獨占線程
        setExclusiveOwnerThread(null);
    }
    // 更新state值
    setState(c);
    return free;
}