ReentrantLock從源碼解析Java多線程同步學習

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}
/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        //CAS修改state狀態
        if (compareAndSetState(0, 1))
           //修改成功設置exclusiveOwnerThread
            setExclusiveOwnerThread(Thread.currentThread());
        else
           //嘗試獲取資源
            acquire(1);
    }

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

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

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    //獲取當前資源標識
    int c = getState();
    if (c == 0) {
        //如果資源沒被占有CAS嘗試加鎖
        if (compareAndSetState(0, acquires)) {
            //修改成功設置exclusiveOwnerThread
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //資源被占有要判斷占有資源的線程是不是當前線程，加鎖成功設置的exclusiveOwnerThread值在這裡就派上瞭用處
    else if (current == getExclusiveOwnerThread()) {
        //這下面就是將重入次數設置到資源標識裡
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

private Node addWaiter(Node mode) {
    //構建一個當前線程的node節點 這裡prev 和 next 都為null
    Node node = new Node(Thread.currentThread(), mode);
    // 指向雙向鏈表的尾節點的引用
    Node pred = tail;
    //B線程進來目前還未構建任何隊列這裡肯定是空的
    if (pred != null) {
        //如果已經構建過隊列會把當前線程的node節點的上一個node節點指向tail尾節點
        node.prev = pred;
        //CAS操作把當前線程的node節點設置為新的tail尾節點
        if (compareAndSetTail(pred, node)) {
            //把舊的tail尾節點的下一個node節點指向當前線程的node節點
            pred.next = node;
            return node;
        }
    }
    //尾節點為空執行
    enq(node);
    return node;
}

private Node enq(final Node node) {
    //死循環當tail 尾節點不為空才會跳出
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            //用CAS構建出一個head空的node節點
            if (compareAndSetHead(new Node()))
            //將當前空的node節點交給尾節點（下一次循環就會走else分支）
                tail = head;
        } else {
            //把我們addWaiter中創建的node節點的prev指向瞭當前線程node節點
            node.prev = t;
            //將tail尾節點更改為當前線程的node節點
            if (compareAndSetTail(t, node)) {
                //將t的下一個節點指向當前線程創建的node節點
                t.next = node;
                return t;
            }
        }
    }
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        //中斷標志位
        boolean interrupted = false;
        for (;;) {
            //獲取當前線程node節點的上一個節點
            final Node p = node.predecessor();
            //如果上一個節點就是head節點說明當前線程其實是處在隊列第一位然後就會再次嘗試加鎖
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //這裡是重點 這個方法來判斷當前線程是否應該進入等待狀態
            if (shouldParkAfterFailedAcquire(p, node) &&
                //調用LockSupport.park(this)阻塞瞭當前線程等待被喚醒
                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;
    if (ws > 0) {//當前線程被取消
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        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.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//設置等待狀態為-1
    }
    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)
            //head節點不為空並且等待狀態不是0就去進行unpark操作
            unparkSuccessor(h);
        return true;
    }
    return false;
}

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.
     */
    //head節點等待狀態
    int ws = node.waitStatus;
    //
    if (ws < 0)
       //將頭節點的等待狀態修改為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.
     */
    //獲取頭節點的下一個節點(也就是B節點)
    Node s = node.next;
    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)
        //對該線程進行unpark喚醒(B節點)
        LockSupport.unpark(s.thread);
}

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            //這裡嘗試獲取鎖由於A線程釋放瞭鎖這裡是肯定獲取成功的
            if (p == head && tryAcquire(arg)) {
                //把head設置為當前節點（也就是往前移一位,並且把上一個節點指向指為null）
                setHead(node);
                //把剛剛的上一個節點也指向為null (這裡他就沒引用瞭會被GC回收掉)
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                //剛剛在這裡阻塞現在被喚醒
                parkAndCheckInterrupt())
                //設置標志中斷位為true 然後開始下一次循環
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}