The principle of ReentrantLock (to be continued)

1. Overview

The bottom layer of ReentrantLock is based on AQS, and its construction method returns NonfaireSync and faireSync;
Both synchronizers inherit from Sync, and Sync inherits from AQS!

When new ReentrantLock is used, the synchronizer is returned, by defaultis unfair;

2. Unfair lock locking

2. 1 successfully locked

Call the lock() method and use the CAS mechanism to try to change the state attribute modified by the underlying volatile of AQS to 1. If it succeeds, it will be locked;
If it failsIf there is a competition, enter the acquire() method;

2. 2 lock failed

1. When the lock is already occupied, the state attribute in the shared memory is 1, compareAndSet(0,1) will fail, and the CAS will fail to change the state attribute, and the acquire() method will be entered;
2. Enter the acquire() method of AQS in else;
3. Call tryAcquire() and try again, the result is false, the negation is true, and then execute acquireQueued(), it will create a NodeThe node object is associated with the thread and placed in the FIFO waiting queue (doubly linked list);
4. After the node enters the queue, it will try to lock in a loop. If it fails, it will be blocked by park. The node's waitStatus will be set to -1, and the node will be woken up by the pre-order node later;

The acquire() method in AQS:

Suppose multiple threads fail to compete and enter the FIFO waiting queue:

2. Unfair lock release

2.1 Competitive Success

1. Call the unlock() method, the bottom layer calls the release() method, use tryRelease() to state>Set to 0 to release the lock;
After
2. tryRelease() returns true, judge whether the head sentinel node is null, if not and the waitStatus of the sentinel node will not be 0(-1), the successor node of the sentinel node is awakened by unParkSuccessor!Then this successor node will be removed from the FIFO queue;

2.1 competition failed