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

    public void lock() {
        sync.lock();
    }

       final void lock() {
            // state表示鎖重入次數(shù) 0代表無鎖狀態(tài)
            //嘗試搶占鎖一次  利用cas替換state標志 替換成功代表搶占鎖成功
            if (compareAndSetState(0, 1))
		//搶占成功將搶占到鎖的線程設置為當前線程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

	final void lock() {
            acquire(1);
        }

public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))		
	//這里acquireQueued()是一步步將線程是否中斷的標志傳回來的 如果為true 那么代表線程被中斷過 需要設置中斷標志 交給客戶端處理
	// 因為LockSupport.park()之后不會對中斷進行響應 所以需要一步一步將中斷標記傳回來
            selfInterrupt();
        }

	protected final boolean tryAcquire(int acquires) {
	    //獲取當前線程
            final Thread current = Thread.currentThread();
	    //獲取state的值
            int c = getState();
            if (c == 0) {
	    //如果state為0 代表現(xiàn)在是無鎖狀態(tài) 那么可以搶占鎖
	    //公平鎖這里多了一個判斷 只有在AQS鏈表中不存在元素 才去嘗試搶占鎖 否則就去鏈表中排隊
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
		//cas替換成功 那么就代表搶占鎖成功了 將獲取鎖的線程設置為當前線程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
	//判斷獲取鎖的線程是否是當前線程 如果是的話增加重入次數(shù) (即增加state的值)
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

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

	final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
		//如果state為0 代表現(xiàn)在是無鎖狀態(tài) 非公平鎖這里就直接嘗試搶占鎖
		// 公平鎖這里多了一個判斷 先去看AQS鏈表中有沒有已經(jīng)在等待的線程 有的話就不會嘗試去搶占鎖了，非公平鎖這里沒有這個判斷，也就是這里允許插隊（不公平）
                if (compareAndSetState(0, acquires)) {	
		//cas替換成功 那么就代表搶占鎖成功了 將獲取鎖的線程設置為當前線程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
	   //判斷獲取鎖的線程是否是當前線程 如果是的話增加重入次數(shù) (即增加state的值)
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //重新設置state的值    
                setState(nextc);
                return true;
            }
            return false;
        }

    static final class Node {
        static final Node SHARED = new Node();
        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;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        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() {    // Used to establish initial head or SHARED marker
        }
        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }
        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

private Node addWaiter(Node mode) {
	//將沒有獲得鎖的線程封裝成一個node 
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
	//如果AQS尾結(jié)點不為null 代表AQS鏈表已經(jīng)初始化 嘗試將構建好的節(jié)點添加到鏈表的尾部
        if (pred != null) {
            node.prev = pred;
	    //cas替換AQS的尾結(jié)點 
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
	//沒有初始化調(diào)用enq()方法
        enq(node);
        return node;
    }

private Node enq(final Node node) {
	    //自旋
        for (;;) {
            Node t = tail;
	    //尾結(jié)點為空 說明AQS鏈表還沒有初始化 那么進行初始化
            if (t == null) { // Must initialize
	    //cas 將AQS的head節(jié)點 初始化 成功初始化head之后，將尾結(jié)點也初始化
            //注意 這里我們可以看到head節(jié)點是不存儲線程信息的 也就是說head節(jié)點相當于是一個虛擬節(jié)點
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
		//尾結(jié)點不為空 那么直接添加到鏈表的尾部即可
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
	    //進入自旋
            for (;;) {
		//獲取當前節(jié)點的前一個節(jié)點
                final Node p = node.predecessor();
		// 如果前一個節(jié)點是head 而且再次嘗試獲取鎖成功，將節(jié)點從AQS隊列中去除 并替換head 同時返回中斷標志
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    //注意 只有搶占到鎖才會跳出這個for循環(huán)
                    return interrupted;
                }
                //去除狀態(tài)為CANCELLED的節(jié)點 并且阻塞線程 線程被阻塞在這
                //注意 線程被喚醒之后繼續(xù)執(zhí)行這個for循環(huán) 嘗試搶占鎖 沒有搶占到的話又會阻塞
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                //如果失敗 將node狀態(tài)修改為CANCELLED
                cancelAcquire(node);
        }
    }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
	    //如果節(jié)點是SIGNAL狀態(tài) 不需要處理 直接返回
            return true;
        if (ws > 0) {
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
	   //如果節(jié)點狀態(tài)>0 說明節(jié)點是取消狀態(tài) 這種狀態(tài)的節(jié)點需要被清除 用do while循環(huán)順便清除一下前面的連續(xù)的、狀態(tài)為取消的節(jié)點
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
	    //正常的情況下 利用cas將前一個節(jié)點的狀態(tài)替換為 SIGNAL狀態(tài) 也就是-1
	    //注意 這樣隊列中節(jié)點的狀態(tài) 除了最后一個都是-1 包括head節(jié)點
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

private final boolean parkAndCheckInterrupt() {
  //掛起當前線程 并且返回中斷標志  LockSupport.park(thread) 會調(diào)用UNSAFE.park()方法將線程阻塞起來（是一個native方法）
        LockSupport.park(this);
        return Thread.interrupted();
    }

public void unlock() {
	    //每次調(diào)用unlock 將state減1
        sync.release(1);
}

public final boolean release(int arg) {
	//只有tryRelease返回true 說明已經(jīng)釋放鎖 需要將阻塞的線程喚醒 否則不需要喚醒別的線程
        if (tryRelease(arg)) {
            Node h = head;
	//如果頭結(jié)點不為空 而且狀態(tài)不為0 代表同步隊列已經(jīng)初始化 且存在需要喚醒的node
	//注意 同步隊列的頭結(jié)點相當于是一個虛擬節(jié)點  這一點我們可以在構建節(jié)點的代碼中很清楚的知道
	//并且在shouldParkAfterFailedAcquire方法中 會把head節(jié)點的狀態(tài)修改為-1
	//如果head的狀態(tài)為0 那么代表隊列中沒有需要被喚醒的元素 直接返回true
            if (h != null && h.waitStatus != 0)
		//喚醒頭結(jié)點的下一個節(jié)點
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

protected final boolean tryRelease(int releases) {
	     //減少重入次數(shù)
            int c = getState() - releases;
	    //如果獲取鎖的線程不是當前線程 拋出異常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
	    //如果state為0 說明已經(jīng)徹底釋放了鎖 返回true
            if (c == 0) {
                free = true;
		//將獲取鎖的線程設置為null
                setExclusiveOwnerThread(null);
            }
	    //重置state的值
            setState(c);
	    //如果釋放了鎖 就返回true 否則返回false
            return free;
        }

private void unparkSuccessor(Node node) {
        //獲取頭結(jié)點的狀態(tài) 將頭結(jié)點狀態(tài)設置為0 代表現(xiàn)在正在有線程被喚醒 如果head狀態(tài)為0 就不會進入這個方法了
        int ws = node.waitStatus;
        if (ws < 0)
            //將頭結(jié)點狀態(tài)設置為0
            compareAndSetWaitStatus(node, ws, 0);
        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
	//喚醒頭結(jié)點的下一個狀態(tài)不是cancelled的節(jié)點 （因為頭結(jié)點是不存儲阻塞線程的）
        Node s = node.next;
	//當前節(jié)點是null 或者是cancelled狀態(tài)
        if (s == null || s.waitStatus > 0) {
            s = null;
	 //從aqs鏈表的尾部開始遍歷 找到離頭結(jié)點最近的 不為空的 狀態(tài)不是cancelled的節(jié)點 賦值給s 這里為什么從尾結(jié)點開始遍歷而是頭結(jié)點 應該是因為添加結(jié)點的時候是先初始化結(jié)點的prev的， 從尾結(jié)點開始遍歷 不會出現(xiàn)prve沒有賦值的情況 
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
	    //調(diào)用LockSupport.unpark()喚醒指定的線程
            LockSupport.unpark(s.thread);
    }