@Test
public void testUnfairLock() throws InterruptedException {
    // 無參構(gòu)造函數(shù)，默認(rèn)創(chuàng)建非公平鎖模式
    ReentrantLock reentrantLock = new ReentrantLock();

    for (int i = 0; i < 10; i++) {
        final int threadNum = i;
        new Thread(() -> {
            reentrantLock.lock();
            try {
                System.out.println("線程" + threadNum + "獲取鎖");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // finally中解鎖
                reentrantLock.unlock();
                System.out.println("線程" + threadNum +"釋放鎖");
            }
        }).start();
        Thread.sleep(999);
    }

    Thread.sleep(100000);
}

public ReentrantLock() {
 	sync = new NonfairSync();
}

// ReentrantLock.NonfairSync#lock
final void lock() {
    // 用 cas 嘗試（僅嘗試一次）將 state 從 0 改為 1, 如果成功表示【獲得了獨(dú)占鎖】
    if (compareAndSetState(0, 1))
        // 設(shè)置當(dāng)前線程為獨(dú)占線程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);//失敗進(jìn)入
}

// AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {
    // tryAcquire 嘗試獲取鎖失敗時(shí), 會(huì)調(diào)用 addWaiter 將當(dāng)前線程封裝成node入隊(duì)，acquireQueued 阻塞當(dāng)前線程，
    // acquireQueued 返回 true 表示掛起過程中線程被中斷喚醒過，false 表示未被中斷過
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        // 如果線程被中斷了邏輯來到這，完成一次真正的打斷效果
        selfInterrupt();
}

// ReentrantLock.NonfairSync#tryAcquire
protected final boolean tryAcquire(int acquires) {
    return nonfairTryAcquire(acquires);
}
// 搶占成功返回 true，搶占失敗返回 false
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // state 值
    int c = getState();
    // 條件成立說明當(dāng)前處于【無鎖狀態(tài)】
    if (c == 0) {
        //如果還沒有獲得鎖，嘗試用cas獲得，這里體現(xiàn)非公平性: 不去檢查 AQS 隊(duì)列是否有阻塞線程直接獲取鎖        
    	if (compareAndSetState(0, acquires)) {
            // 獲取鎖成功設(shè)置當(dāng)前線程為獨(dú)占鎖線程。
            setExclusiveOwnerThread(current);
            return true;
         }    
	} 
    // 這部分是重入鎖的原理    
   	// 如果已經(jīng)有線程獲得了鎖, 獨(dú)占鎖線程還是當(dāng)前線程, 表示【發(fā)生了鎖重入】
	else if (current == getExclusiveOwnerThread()) {
        // 更新鎖重入的值
        int nextc = c + acquires;
        // 越界判斷，當(dāng)重入的深度很深時(shí)，會(huì)導(dǎo)致 nextc < 0，int值達(dá)到最大之后再 + 1 變負(fù)數(shù)
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 更新 state 的值，這里不使用 cas 是因?yàn)楫?dāng)前線程正在持有鎖，所以這里的操作相當(dāng)于在一個(gè)管程內(nèi)
        setState(nextc);
        return true;
    }
    // 獲取失敗
    return false;
}

// AbstractQueuedSynchronizer#addWaiter，返回當(dāng)前線程的 node 節(jié)點(diǎn)
private Node addWaiter(Node mode) {
    // 將當(dāng)前線程關(guān)聯(lián)到一個(gè) Node 對(duì)象上, 模式為獨(dú)占模式   
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    // 快速入隊(duì)，如果 tail 不為 null，說明存在阻塞隊(duì)列
    if (pred != null) {
        // 將當(dāng)前節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)指向 尾節(jié)點(diǎn)
        node.prev = pred;
        // 通過 cas 將 Node 對(duì)象加入 AQS 隊(duì)列，成為尾節(jié)點(diǎn)，【尾插法】
        if (compareAndSetTail(pred, node)) {
            pred.next = node;// 雙向鏈表
            return node;
        }
    }
    // 初始時(shí)隊(duì)列為空，或者 CAS 失敗進(jìn)入這里
    enq(node);
    return node;
}

// AbstractQueuedSynchronizer#enq
private Node enq(final Node node) {
    // 自旋入隊(duì)，必須入隊(duì)成功才結(jié)束循環(huán)
    for (;;) {
        Node t = tail;
        // 說明當(dāng)前鎖被占用，且當(dāng)前線程可能是【第一個(gè)獲取鎖失敗】的線程，【還沒有建立隊(duì)列】
        if (t == null) {
            // 設(shè)置一個(gè)【啞元節(jié)點(diǎn)】，頭尾指針都指向該節(jié)點(diǎn)
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            // 自旋到這，普通入隊(duì)方式，首先賦值尾節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)【尾插法】
            node.prev = t;
            // 【在設(shè)置完尾節(jié)點(diǎn)后，才更新的原始尾節(jié)點(diǎn)的后繼節(jié)點(diǎn)，所以此時(shí)從前往后遍歷會(huì)丟失尾節(jié)點(diǎn)】
            if (compareAndSetTail(t, node)) {
                //【此時(shí) t.next  = null，并且這里已經(jīng) CAS 結(jié)束，線程并不是安全的】
                t.next = node;
                return t;	// 返回當(dāng)前 node 的前驅(qū)節(jié)點(diǎn)
            }
        }
    }
}

inal boolean acquireQueued(final Node node, int arg) {
    // true 表示當(dāng)前線程搶占鎖失敗，false 表示成功
    boolean failed = true;
    try {
        // 中斷標(biāo)記，表示當(dāng)前線程是否被中斷
        boolean interrupted = false;
        for (;;) {
            // 獲得當(dāng)前線程節(jié)點(diǎn)的前驅(qū)節(jié)點(diǎn)
            final Node p = node.predecessor();
            // 前驅(qū)節(jié)點(diǎn)是 head, FIFO 隊(duì)列的特性表示輪到當(dāng)前線程可以去獲取鎖
            if (p == head && tryAcquire(arg)) {
                // 獲取成功, 設(shè)置當(dāng)前線程自己的 node 為 head
                setHead(node);
                p.next = null; // help GC
                // 表示搶占鎖成功
                failed = false;
                // 返回當(dāng)前線程是否被中斷
                return interrupted;
            }
            // 判斷是否應(yīng)當(dāng) park，返回 false 后需要新一輪的循環(huán)，返回 true 進(jìn)入條件二阻塞線程
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                // 條件二返回結(jié)果是當(dāng)前線程是否被打斷，沒有被打斷返回 false 不進(jìn)入這里的邏輯
                // 【就算被打斷了，也會(huì)繼續(xù)循環(huán)，并不會(huì)返回】
                interrupted = true;
        }
    } finally {
        // 【可打斷模式下才會(huì)進(jìn)入該邏輯】
        if (failed)
            cancelAcquire(node);
    }
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 表示前置節(jié)點(diǎn)是個(gè)可以喚醒當(dāng)前節(jié)點(diǎn)的節(jié)點(diǎn)，返回 true
    if (ws == Node.SIGNAL)
        return true;
    // 前置節(jié)點(diǎn)的狀態(tài)處于取消狀態(tài)，需要【刪除前面所有取消的節(jié)點(diǎn)】, 返回到外層循環(huán)重試
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        // 獲取到非取消的節(jié)點(diǎn)，連接上當(dāng)前節(jié)點(diǎn)
        pred.next = node;
    // 默認(rèn)情況下 node 的 waitStatus 是 0，進(jìn)入這里的邏輯
    } else {
        // 【設(shè)置上一個(gè)節(jié)點(diǎn)狀態(tài)為 Node.SIGNAL】，返回外層循環(huán)重試
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    // 返回不應(yīng)該 park，再次嘗試一次
    return false;
}

private final boolean parkAndCheckInterrupt() {
    // 阻塞當(dāng)前線程，如果打斷標(biāo)記已經(jīng)是 true, 則 park 會(huì)失效
    LockSupport.park(this);
    // 判斷當(dāng)前線程是否被打斷，清除打斷標(biāo)記
    return Thread.interrupted();
}

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

// AbstractQueuedSynchronizer#release
public final boolean release(int arg) {
    // 嘗試釋放鎖，tryRelease 返回 true 表示當(dāng)前線程已經(jīng)【完全釋放鎖，重入的釋放了】
    if (tryRelease(arg)) {
        // 隊(duì)列頭節(jié)點(diǎn)
        Node h = head;
        // 頭節(jié)點(diǎn)什么時(shí)候是空？沒有發(fā)生鎖競爭，沒有競爭線程創(chuàng)建啞元節(jié)點(diǎn)
        // 條件成立說明阻塞隊(duì)列有等待線程，需要喚醒 head 節(jié)點(diǎn)后面的線程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }    
    return false;
}

// ReentrantLock.Sync#tryRelease
protected final boolean tryRelease(int releases) {
    // 減去釋放的值，可能重入
    int c = getState() - releases;
    // 如果當(dāng)前線程不是持有鎖的線程直接報(bào)錯(cuò)
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否已經(jīng)完全釋放鎖
    boolean free = false;
    // 支持鎖重入, 只有 state 減為 0, 才完全釋放鎖成功
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 當(dāng)前線程就是持有鎖線程，所以可以直接更新鎖，不需要使用 CAS
    setState(c);
    return free;
}

private void unparkSuccessor(Node node) {
    // 當(dāng)前節(jié)點(diǎn)的狀態(tài)
    int ws = node.waitStatus;    
    if (ws < 0)        
        // 【嘗試重置狀態(tài)為 0】，因?yàn)楫?dāng)前節(jié)點(diǎn)要完成對(duì)后續(xù)節(jié)點(diǎn)的喚醒任務(wù)了，不需要 -1 了
        compareAndSetWaitStatus(node, ws, 0);    
    // 找到需要 unpark 的節(jié)點(diǎn)，當(dāng)前節(jié)點(diǎn)的下一個(gè)    
    Node s = node.next;    
    // 已取消的節(jié)點(diǎn)不能喚醒，需要找到距離頭節(jié)點(diǎn)最近的非取消的節(jié)點(diǎn)
    if (s == null || s.waitStatus > 0) {
        s = null;
        // AQS 隊(duì)列【從后至前】找需要 unpark 的節(jié)點(diǎn)，直到 t == 當(dāng)前的 node 為止，找不到就不喚醒了
        for (Node t = tail; t != null && t != node; t = t.prev)
            // 說明當(dāng)前線程狀態(tài)需要被喚醒
            if (t.waitStatus <= 0)
                // 置換引用
                s = t;
    }
    // 【找到合適的可以被喚醒的 node，則喚醒線程】
    if (s != null)
        LockSupport.unpark(s.thread);
}

@Test
public void testfairLock() throws InterruptedException {
    // 有參構(gòu)造函數(shù)，true表示公平鎖，false表示非公平鎖
    ReentrantLock reentrantLock = new ReentrantLock(true);

    for (int i = 0; i < 10; i++) {
        final int threadNum = i;
        new Thread(() -> {
            reentrantLock.lock();
            try {
                System.out.println("線程" + threadNum + "獲取鎖");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // finally中解鎖
                reentrantLock.unlock();
                System.out.println("線程" + threadNum +"釋放鎖");
            }
        }).start();
        Thread.sleep(10);
    }

    Thread.sleep(100000);
}

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    final void lock() {
        acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            // 先檢查 AQS 隊(duì)列中是否有前驅(qū)節(jié)點(diǎn), 沒有(false)才去競爭
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 鎖重入
        return false;
    }
}

public final boolean hasQueuedPredecessors() {    
    Node t = tail;
    Node h = head;
    Node s;    
    // 頭尾指向一個(gè)節(jié)點(diǎn)，鏈表為空，返回false
    return h != t &&
        // 頭尾之間有節(jié)點(diǎn)，判斷頭節(jié)點(diǎn)的下一個(gè)是不是空
        // 不是空進(jìn)入最后的判斷，第二個(gè)節(jié)點(diǎn)的線程是否是本線程，不是返回 true，表示當(dāng)前節(jié)點(diǎn)有前驅(qū)節(jié)點(diǎn)
        ((s = h.next) == null || s.thread != Thread.currentThread());
}