Reentrantlock source code analysis

Preface

Java Language directly provides synchronized Keyword is used to lock , But this kind of lock is very heavy , Second, we must wait all the time when we get it , There's no extra trial mechanism .

java.util.concurrent.locks Provided by the package ReentrantLock Used in substitution synchronized Lock , Let's take a look at the traditional synchronized Code ：

public class Counter {

    private int count;

    public void add(int n) {
        synchronized(this) {
            count += n;
        }
    }
}

ReentrantLock Use samples .

public class Counter {

    private final Lock lock = new ReentrantLock();
    private int count;

    public void add(int n) {
        lock.lock();
        try {
            count += n;
        } finally {
            lock.unlock();
        }
    }
}

Constructors

ReentrantLock Default is unfair lock .

If new ReentrantLock(true), Fair lock , Otherwise it's unfair lock .

/**
 *  Default is unfair lock 
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

/**
 *  see boolean Value ,true Lock for fairness ,false Lock for unfairness .
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

Sync

Used here Sync Is a synchronizer that provides all the implementation mechanisms , Is an abstract class , Inherit AbstractQueuedSynchronizer( namely AQS).

private final Sync sync;

/**
 *  Synchronization control basis of this lock . The following is divided into fair and unfair versions . Use  AQS  State to indicate the number of times the lock is held 
 */
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = -5179523762034025860L;

    /**
     *  abstract lock
     */
    abstract void lock();

    /**
     *  Execution is not fair tryLock.tryAcquire Implemented in subclass , But both need non empty trylock Method 
     */
    final boolean nonfairTryAcquire(int acquires) {

        final Thread current = Thread.currentThread();

        // Get lock status , It uses AQS volatile state state 
        int c = getState();

        if (c == 0) {
            // If the state is 0, Indicates that there is no thread lock . Then use CAS Get the lock 
            if (compareAndSetState(0, acquires)) {
                // To be successful , Set the thread holding the current lock as the current thread 
                setExclusiveOwnerThread(current);
                return true;
            }
        }

        // If the current thread holds a lock , This means re-entry lock 
        else if (current == getExclusiveOwnerThread()) {
             // The modification status is the number of times the lock is acquired 
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

    // Try to release the lock 
    protected final boolean tryRelease(int releases) {
        int c = getState() - releases;
        // The current thread does not hold a lock , Throw the wrong 
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();

        // Whether the flag is completely released 
        boolean free = false;
        //c by 0, It indicates that the status is fully released 
        if (c == 0) {
            // Change logo to true, And change the thread holding the lock to null 
            free = true;
            setExclusiveOwnerThread(null);
        }

        // Reset the state of the lock , And return to the state of releasing the lock 
        setState(c);
        return free;
    }

    // Determine whether the current thread holds the lock 
    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    // Get a new one Condition object 
    final ConditionObject newCondition() {
        return new ConditionObject();
    }

    // Get the thread holding the current lock , When it comes to 0 It means that there is no thread , Otherwise, get the current thread that holds the lock 
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }

    // Gets the number of times the current lock is held 
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }

    // Determine whether a thread holds the current lock 
    final boolean isLocked() {
        return getState() != 0;
    }

    /**
     * Reconstitutes the instance from a stream (that is, deserializes it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

FairSync： Fair lock

Inheritance relationships

Source code analysis

/**
 * Sync object for fair locks
 */

static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;

    final void lock() {
        acquire(1);
    }

    // Fair lock version tryAcquire
    protected final boolean tryAcquire(int acquires) {

        final Thread current = Thread.currentThread();

        // Get lock status 
        int c = getState();
        // The current lock status is 0, That is, no thread holds 
        if (c == 0) {
            //hasQueuedPredecessors： Determine whether there are other threads ahead of the current thread .
            // If the current thread does not have , also CAS success , Then directly set the thread holding the lock as the current thread 
            if (!hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }

        // If the current thread holds a lock , This means re-entry lock 
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            return true;
        }
        return false;
    }

}

among hasQueuedPredecessors() function , Method from AQS. Used to determine whether other threads are ahead of the current thread .

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&((s = h.next) == null || s.thread != Thread.currentThread());
}

NonfairSync： Not fair lock

Inheritance relationships

The source code parsing

/**
 * Sync object for non-fair locks
 */
static final class NonfairSync extends Sync {

    private static final long serialVersionUID = 7316153563782823691L;  

    // call lock When the method is used , Direct processing 
    final void lock() {
        // Just try to get the lock , To be successful , Then directly set the thread holding the lock as the current thread 
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

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

acquire() Methods come from the parent class AQS in , The first is to call tryAcquire Method attempts to acquire the lock , If it fails, call addWaiter Method wraps a thread as Node. Then spin CAS The team , And then acquireQueued Method to complete thread blocking .

public final void acquire(int arg) {

    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

The difference between fair lock and unfair lock

We can see from the source code analysis that , There are several differences ：

Lock type	efficiency	Threads execute	The implementation of
Fair lock	Relatively inefficient , Because every time I have to ask	Sunshine , Each thread has a chance to execute	After the thread enters , First, check whether the queue is empty , If it is empty, it will be locked directly , If it is not empty, it will be queued automatically
Not fair lock	Efficient , The lock status can be , It can be locked directly	Thread starve , Some threads may not execute	After the thread enters , Not in order , Will try to scramble for lock first , If it cannot be obtained, it shall be handled in the way of fair lock

Reentrant lock

A reentry lock is if the thread has acquired the lock , The lock will be acquired again without being blocked by the lock .

The lock acquisition and release process is as follows ：

Thread gets lock again . The lock needs to identify whether the thread acquiring the lock is the thread occupying the lock , If so, success again .

The final release of the lock . Threads repeat n Got the lock for the first time , Then in the first n After releasing the lock for the first time , Other threads can acquire the lock . The final release of the lock requires the lock to count the acquisitions , The count indicates the number of times the current lock has been repeatedly acquired , And when the lock is released , The count subtracts itself , When the counter is equal to 0 Indicates that the lock has been successfully released .