The thread currently occupying the synchronization state

Set exclusive thread

Get the current exclusive thread

static final Node SHARED = new Node()

static final Node EXCLUSIVE = null

static final int CANCELLED = 1

static final int SIGNAL = -1

static final int CONDITION = -2

static final int PROPAGATE = -3

Including the above CANCELLED/SIGNAL/CONDITION/PROPAGATE and 0 (indicating that it is not in these four states), a non-negative number indicates that the node does not require interaction

Precursor node

successor node

The thread corresponding to the node

In the synchronization queue, it indicates whether the node is in a shared or exclusive state, equal to SHARED to indicate sharing, and null to indicate exclusive; in the conditional queue, it indicates a reference to the next node.

Node()

Node(Thread thread, Node mode)

Node(Thread thread, int waitStatus)

final boolean isShared()

final Node predecessor()

The queue uses Node's nextWaiter property as a reference to the next node.

private static final int REINTERRUPT = 1

private static final int THROW_IE = -1

Points to the head node of the conditional queue

Points to the tail node of the condition queue

Make the calling thread enter the waiting queue, release the lock and enter the blocking state. After the node is awakened by signal/signalAll, try to acquire the lock. If the blocking is awakened by an interrupt, it will respond to the interrupt.

private Node addConditionWaiter()

final int fullyRelease(Node node)

final boolean isOnSyncQueue(Node node)

acquireQueued(node, savedState)

unlinkCancelledWaiters

reportInterruptAfterWait

The basic logic is similar to await, with the addition of timeout judgment.

The basic logic is similar to awaitNanos, you can specify the time unit, and ultimately it is converted to nanoseconds for calculation.

The basic logic is similar to await and does not respond to interrupts (that is, selfInterrupt resets the interrupt status)

The basic logic is similar to await, with the addition of a maximum blocking time.

Move the longest waiting thread from the conditional queue to the synchronization queue

protected boolean isHeldExclusively()

private void doSignal(Node first)

Transfer all qualified (not canceled) nodes in the condition queue to the synchronization queue. The basic logic is similar to signal, the difference is that the transferForSignal method is executed in a loop

isHeldExclusively

private void doSignalAll(Node first)

Whether there are threads in the condition queue, the implementation method is to cycle the condition queue from the beginning, if there is a node whose status is CONDITION, it returns true, otherwise it returns false

acquire itself does not respond to interrupts, so the processing of interrupts is to restore the interrupt status

Try to obtain an exclusive lock, return true if successful, false if failed. The specific implementation is completed by subclasses, and thread safety needs to be ensured when obtaining synchronization status.

arg can be understood as a resource that needs to be competed. AQS is represented internally by state, but in fact the specific use is defined by the developer.

Continuously try to acquire locks for threads already in the queue (node ​​has been created by addWaiter)

Implementation logic: Spin as follows: If the predecessor node is head and acquires the lock successfully, set the current node to head and the return is not interrupted; otherwise, proceed to the following operations: call shouldParkAfterFailedAcquire to determine and set the node status and call parkAndCheckInterrupt to block the thread and Check interrupt status. If an exception occurs during the process, call cancelAcquire to cancel the acquisition.

private void setHead(Node node)

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node)

private final boolean parkAndCheckInterrupt()

private void cancelAcquire(Node node)

try it once first

The basic logic is the same as acquireQueued. The difference is that addWaiter is called internally and does not return whether there is a thread interruption, but directly throws an InterruptedException after checking that the park is awakened by the interruption.

try it once first

The basic logic is the same as doAcquireInterruptibly, with the addition of time judgment logic and the use of spinForTimeoutThreshold threshold.

Try to modify the state. There is no specific implementation in AQS and subclasses need to implement it themselves. The arg variable of the release method is used for this method; the return value is whether the state is successfully released

Try to obtain the synchronization status. No specific method is provided in AQS and is implemented by subclasses. A return value less than 0 indicates that the acquisition failed; equal to 0 indicates that the acquisition was successful, but no other shared mode acquisition was successful; greater than 0 indicates that the acquisition was successful and other sharing mode acquisitions may also be successful.

After joining the queue, spin tries to obtain the synchronization status. The basic logic is basically the same as acquireQueued in exclusive mode. The difference is that when the predecessor of the node is head, the result returned by tryAcquireShared needs to be judged. If it is greater than or equal to 0 (indicating that there are still resources, can continue to propagate), then call setHeadAndPropagate to set the head and propagation attributes (set a new head and judge the successor node, and wake it up if appropriate); otherwise, you still need to call shouldParkAfterFailedAcquire and parkAndCheckInterrupt for subsequent operations (park and subsequent interrupt judgment, etc.). In addition, the selfTninterrupt method for setting the interrupt status is also executed in this method.

tryAcquireShared

private void setHeadAndPropagate(Node node, int propagate)

cancelAcquire

Similar to doAcquireShared logic, an exception is thrown after an interruption is detected

The timeout judgment logic is similar to the exclusive mode, and other execution logic is similar to doAcquireShared

Empty method, implemented by subclasses, attempts to release synchronization state. arg is the parameter of releaseShared and can be defined by yourself; the return value is true when this method successfully releases the synchronization state and other threads can acquire, otherwise it returns false

Here we still only wake up a subsequent node, and the subsequent wake-up propagation is carried out by the awakened node.

Implementing queries and obtaining competitive resources is usually completed by the CAS operation of the state. The incoming parameters can be defined by the developer.

To release competing resources, usually the state variable is decremented or cleared to zero. The incoming parameters can be defined by the developer.

The incoming parameters are defined by the developer and can be regarded as the number of resources they want to obtain; the return value int can be regarded as the remaining number of shared resources.

The incoming parameters are defined by developers themselves and can be regarded as the number of resources they want to release.

Returns whether the current thread exclusively occupies the mutex lock corresponding to the condition variable

Is it an abstract method to acquire a lock? Does it need to be implemented by a subclass?

Unfair tryLock implementation The specific implementation is: CAS acquires the lock when no thread currently acquires the lock. If successful, the lock-exclusive thread is set to the current thread; if the current thread already holds the lock, the number of current locks is updated. In these two cases, true will be returned, indicating that the lock is held, and false will be returned in other cases.

The implementation of tryRelease in AQS is to first calculate the total number of locks minus the number of released locks to get the number of remaining held locks c. If c is 0, clear the state; set the state to the value of c and return whether no locks are held.

isHeldExclusively implemented in AQS, return getExclusiveOwnerThread() == Thread.currentThread()

Returns how many locks the current thread holds. This method relies on the judgment of isHeldExclusively

return getState() != 0; Whether a thread holds the lock

Returns the thread holding the lock, or null if not

newConditionObject()

Deserialization method, set state to 0

acquire(1)

TryAcquire implementation of fair lock. The implementation process is: when the occupied lock c is 0, if there is no thread in front and cas successfully sets c to acquires, then set the current thread as an exclusive thread and return true; if the current thread already holds the lock, update the number of locks and return true; Returns false in all other cases

hasQueuedPredecessors

First try direct cas(0,1). If it succeeds, it means that no one else is currently acquiring the lock. The current thread successfully grabbed the lock, and then set the exclusive thread as the current thread; if it fails, acquire(1)

return nonfairTryAcquire(acquires) The unfair implementation already exists in Sync, call it directly

具体的实现与平台相关，每个线程都有一个Parker实例，在linux实现中实际上是以mutex和condition最终实现了锁和阻塞的过程（具体看笔记文章，这里不写了）

主要成员变量（linux实现）

方法