//默認執(zhí)行NonfairSync.lock();
final void lock() {
            //cas 0 -> 1 ,如果操作成功，將當前線程設(shè)置為獨占線程
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //如果操作失敗
                acquire(1);
        }

public final void acquire(int arg) {
        //tryAcquire(arg)嘗試獲取鎖，如果獲取鎖失敗返回false,否則返回true
        if (!tryAcquire(arg) &&
            //嘗試獲得鎖，如果當前線程被中斷 返回 true,否則返回false
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //獲得鎖失敗，且當前線程的中斷狀態(tài)為true,則重新去嘗試
            selfInterrupt();
    }

final boolean nonfairTryAcquire(int acquires) {
            //獲取當前線程
            final Thread current = Thread.currentThread();
            //獲取state值
            int c = getState();
            //0 代表沒有線程占用鎖
            if (c == 0) {
                //cas 將 0 改為 1
                if (compareAndSetState(0, acquires)) {
                    //cas 成功之后 將獨占線程改為當前線程
                    setExclusiveOwnerThread(current);
                    //返回成功
                    return true;
                }
            }
            //如果有線程獲取當前線程(也就是當前線程是獨占線程)
            else if (current == getExclusiveOwnerThread()) {
                //state值加1
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //保存新的state值
                setState(nextc);
                //返回true
                return true;
            }
            //否則，就返回false
            return false;
        }

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        //尾節(jié)點賦值給pred；
        Node pred = tail;
        //尾節(jié)點不為空
        if (pred != null) {
            //當前的節(jié)點prev指針指向現(xiàn)在的尾節(jié)點
            node.prev = pred;
            //cas 將當前尾節(jié)點 替換為 node節(jié)點
            if (compareAndSetTail(pred, node)) {
                //當前尾節(jié)點的next指針指向 node節(jié)點
                pred.next = node;
                return node;
            }
        }
        //如果尾節(jié)點為空或者cas替換失敗，則執(zhí)行入隊操作
        enq(node);
        return node;
    }
    //入隊操作：將當前節(jié)點設(shè)置為尾節(jié)點，并更新當前節(jié)點和替換前的尾節(jié)點的指針指向
    private Node enq(final Node node) {
            for (;;) {
                //把尾節(jié)點賦值給一個變量
                Node t = tail;
                //如果尾節(jié)點為空
                if (t == null) {
                    //新建一個節(jié)點，設(shè)置為頭節(jié)點
                    if (compareAndSetHead(new Node()))
                        //把頭節(jié)點賦值尾節(jié)點
                        tail = head;
                } else {
                    //如果尾節(jié)點不為空，當前節(jié)點的prev指針指向尾節(jié)點
                    node.prev = t;
                    //cas 將當前節(jié)點設(shè)置為尾節(jié)點
                    if (compareAndSetTail(t, node)) {
                        //替換前的尾節(jié)點的next指針指向當前節(jié)點
                        t.next = node;
                        return t;
                    }
                }
                //如果cas 替換尾節(jié)點 失敗，則循環(huán)執(zhí)行，直到成功為止
            }
      }

//已經(jīng)入隊的非中斷線程再次嘗試獲取鎖
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                //獲取當前節(jié)點的前一個節(jié)點信息
                final Node p = node.predecessor();
                //如果前一個節(jié)點信息為頭節(jié)點，并且成功獲得鎖
                if (p == head && tryAcquire(arg)) {
                    //設(shè)置當前節(jié)點為頭節(jié)點
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    //返回當前節(jié)點的線程中斷狀態(tài)
                    return interrupted;
                }
                //如果當前節(jié)點的前驅(qū)節(jié)點不是頭節(jié)點 或者 獲得鎖失敗，則阻塞當前節(jié)點線程等待當前節(jié)點的線程被喚醒，并判斷中斷狀態(tài)
                if (shouldParkAfterFailedAcquire(p, node) &&
                    //阻塞當前線程，等待當前線程被喚醒后，判斷當前線程的中斷狀態(tài)
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

//獲取鎖失敗的線程檢查并更新node中的waitStatus。如果線程應該被阻塞返回true。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //獲取前一個節(jié)點的等待狀態(tài)
        int ws = pred.waitStatus;
        //-1，代表前一個節(jié)點被阻塞中,需要喚醒
        if (ws == Node.SIGNAL)
            return true;
        if (ws > 0) {
            // > 0 代表前一個節(jié)點被取消，就遞歸往找waitStatus > 0的節(jié)點信息
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            //找到后，將此節(jié)點的next指針指向當前節(jié)點
            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.
             * waitStatus 必須是0 或者 -3(表示可以共享獲得)。表明我們需要喚醒，但是還沒有阻塞。調(diào)用者需要重試去保證在阻塞操作之前不能獲取成功
             */
            //cas 將 前一個節(jié)點的waitStatus 改為 -1（需要喚醒）
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        //返回false
        return false;
    }
    private final boolean parkAndCheckInterrupt() {
        //阻塞當前線程
        LockSupport.park(this);
        //當前線程被喚醒后，判斷當前線程的的中斷狀態(tài)
        //這里有一個非常重要的知識點：喚醒阻塞線程的方式 1.unpark 2.interrupt
        return Thread.interrupted();
    }