摘要：原理全稱，當(dāng)線程去獲取資源的時(shí)候，會(huì)根據(jù)狀態(tài)值來判斷是否有鎖，如果有鎖，則加入到鏈表，鏈表里的線程，通過自旋，判斷資源是否已經(jīng)釋放，如果釋放，則獲取資源。

全稱AbstractQueuedSynchronizer，當(dāng)線程去獲取資源的時(shí)候，會(huì)根據(jù)狀態(tài)值state來判斷是否有鎖，如果有鎖，則加入到鏈表，鏈表里的線程，通過自旋，判斷資源是否已經(jīng)釋放，如果釋放，則獲取資源。

volatile Node head：阻塞的頭節(jié)點(diǎn)

volatile Node tail：阻塞的尾節(jié)點(diǎn)，新的阻塞節(jié)點(diǎn)加到最后

volatile int state：鎖的狀態(tài)，0說明未占用，大于等于1說明已占用

Thread exclusiveOwnerThread：占用鎖的當(dāng)前線程

Node EXCLUSIVE：獨(dú)占模式

volatile Thread thread：當(dāng)前線程

volatile Node prev：前置節(jié)點(diǎn)

volatile Node next：后置節(jié)點(diǎn)

volatile int waitStatus：狀態(tài)字段，-1：等待被喚醒，大于0，被取消

這里以非公平鎖為例

獲取鎖

final void lock() {
    if (compareAndSetState(0, 1))//如果狀態(tài)是0，則設(shè)置為1
        setExclusiveOwnerThread(Thread.currentThread());//設(shè)置占用鎖為當(dāng)前的線程
    else
        acquire(1);//資源被占用
}

鎖被占用后，再嘗試獲取，獲取不到，進(jìn)入阻塞隊(duì)列

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

調(diào)用的是Sync的nonfairTryAcquire方法。

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();//獲取當(dāng)前線程
    int c = getState();//獲取當(dāng)前狀態(tài)
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {//為當(dāng)前線程，重入
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

把線程封裝成node，加入隊(duì)列

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;//獲取尾節(jié)點(diǎn)
    if (pred != null) {
        node.prev = pred;//當(dāng)前節(jié)點(diǎn)的前置節(jié)點(diǎn)為獲取到的尾節(jié)點(diǎn)
        if (compareAndSetTail(pred, node)) {//設(shè)置當(dāng)前節(jié)點(diǎn)為尾節(jié)點(diǎn)
            pred.next = node;//如果cas操作成功，設(shè)置雙向鏈表
            return node;
        }
    }
    enq(node);
    return node;
}

通過自旋的方式，加入到尾節(jié)點(diǎn)

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;//獲取尾節(jié)點(diǎn)
        if (t == null) { // 如果尾節(jié)點(diǎn)為空，初始化頭節(jié)點(diǎn)和尾節(jié)點(diǎn)，地址為同一個(gè)
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {//加入尾節(jié)點(diǎn)
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();//獲取前置節(jié)點(diǎn)
            if (p == head && tryAcquire(arg)) {//如果前置節(jié)點(diǎn)是head，并且獲取到了鎖
                setHead(node);//把當(dāng)前節(jié)點(diǎn)設(shè)置到head上面
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //如果既不是隊(duì)頭，或者沒有搶過其他線程
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())//如果隊(duì)頭是喚醒的狀態(tài)，就用parkAndCheckInterrupt掛起
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;//喚醒，返回true
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;//如果被取消了，被取消的前置節(jié)點(diǎn)替換當(dāng)前節(jié)點(diǎn)的前置節(jié)點(diǎn)
        } 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.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//前置節(jié)點(diǎn)狀態(tài)設(shè)置為喚醒
    }
    return false;
}

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);//喚醒頭節(jié)點(diǎn)
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    int c = getState() - releases;//可能重入的情況
    if (Thread.currentThread() != getExclusiveOwnerThread())//非當(dāng)前線程拋異常
        throw new IllegalMonitorStateException();
    boolean free = false;
    if (c == 0) {//不用cas是因?yàn)閮H有當(dāng)前顯示有鎖
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

 private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);//如果頭節(jié)點(diǎn)當(dāng)前waitStatus<0, 修改為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.
     */
    Node s = node.next;
    //喚醒下一個(gè)節(jié)點(diǎn)，如果第一個(gè)為空，從尾部遍歷上去，獲取最前面的waitStatus 小于0的節(jié)點(diǎn)
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);//喚醒
}