Before introducing the ReentrantLock implementation, I'd like to take a look at Doug Lea, the author of util.concurrent package, which is more difficult to read than others. Mr. Doug Lea, who always has a modest and shy smile on his face, uses a lot of relatively complex logical judgments, such as multiple or multiple methods in a judgment condition, which makes it difficult for you to keep up with his rhythm and to figure out his design ideas. It's not that I'm too dishy to force myself in a low voice, leaving behind unskilled tears.

 

Inheritance Diagram

The acquire method does so many things.

1. tryAcquire() tries to get resources, and returns directly if it succeeds.

2. addWaiter() adds the thread to the waiting queue and updates the AQS queue chain information

3. acquireQueued() causes threads to retrieve resources in a waiting queue until they retrieve resources. If the whole waiting process is interrupted, return true, otherwise return false.

4. selfInterrupt() interrupts itself. If the thread is interrupted while waiting, it will not respond. The interruption will be filled only after the resource is obtained.

 

protected final boolean tryAcquire(int acquires) {
    // Get the current thread
    final Thread current = Thread.currentThread();
    // Obtain lock Object's lock state, if the lock is free state=0，If locked, it is 1, greater than 1 means reentry.
    int c = getState();

    // c=0 Represents that no lock is occupied, and the current thread can directly access lock resource execution
    if (c == 0) {
        // Here's an introduction hasQueuedPredecessors()Method: Determine if you need to queue up
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // CAS Operational settings state
            // Set the current thread to a thread with a lock
            setExclusiveOwnerThread(current);
            return true;
        }
    }

    // Non-reentrant locks return directly false，Failure to lock
    else if (current == getExclusiveOwnerThread()) {
        // If re-entry lock, state Plus 1 (acquires)
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

 

HasQueued Predecessors Method

public final boolean hasQueuedPredecessors() {
    // Getting the information of the queue's head and tail nodes
    Node t = tail; 
    Node h = head;
    Node s;
    // h != t There are several situations.
    // 1,The queue has not yet been initialized. The first thread acquires the lock resource.
    //    here h and t All are null, h != t Return fasle Initialization queue
    // 2,The queue has been initialized, and other threads try to get resources.
    //    At this time, the head and tail nodes are different. h!=t Return true，
    //    Continue to judge s.thread != Thread.currentThread() The thread currently competing for the lock is the same thread as the first queued thread.,You need to queue up.
    // 3,The queue has been initialized, but there is only one data in the queue due to lock release.
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

 

addWaiter method

private Node addWaiter(Node mode) {
    // AQS The element type in the queue is Node，You need to encapsulate the current thread into one Node object
    Node node = new Node(Thread.currentThread(), mode);

    // tail For the end of the team, assign a value to pred
    Node pred = tai
    // judge pred Whether the queue is empty or not is actually to determine whether there are nodes at the end of the queue. In fact, as long as the queue is initialized, the end of the queue is certainly not empty.
    if (pred != null) {
        // Assemble node Queue Chain Processes
        // Directly encapsulating the current thread node The last node is set to pred That's the end of the original team.
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            // pred The next node is set to node
            pred.next = node;
            return node;
        }
    }

    // Splicing aqs Queue Chain
    enq(node);
    return node;
}


private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

 

acquireQueued method