AQS Abstract queue synchronizer

AQS What is it?

Abstract queue synchronizer

AbstractOwnableSynchronizer
AbstractQueuedLongSynchronizer
AbstractQueuedSynchronizer Usually ：AbstractQueuedSynchronizer Referred to as AQS

explain ：

Is used to build locks or other synchronizer components The heavyweight infrastructure and the whole JUC The cornerstone of the system ,
Through the built-in FIFO Queue to complete the queuing of resource acquisition thread , And through a int Class variables represent the state of holding the lock

CLH：Craig、Landin and Hagersten queue , It's a one-way list ,AQS The queue in is CLH Virtual two-way queues for variants FIFO

AQS Why JUC The most important cornerstone of content

The relationship between lock and synchronizer

lock , For lock users ： It defines the use layer of programmer and lock interaction API, Hidden implementation details , You can call .

synchronizer , Lock oriented implementers ： such as Java Concurrent God DougLee, A unified specification is proposed and the implementation of lock is simplified , The synchronization state management is blocked 、 Blocking thread queuing and notification 、 Wake up mechanism, etc .

effect

Locking can cause blocking , If there is a jam, you need to line up , Queue is necessary to realize queuing

The thread that grabs the resource directly processes the business , Those who can't grab resources must involve a kind of Queuing mechanism . Threads that fail to preempt resources continue to wait ( Similar banking business processing windows are full , Customers who do not have an acceptance window can only go to Wait in line in the waiting area ), However, the waiting thread still retains the possibility of acquiring locks, and the process of acquiring locks continues ( Customers in the waiting area are also waiting for a call , It's time to go to the reception window to handle business ).

Now that we're here Queuing mechanism , Then there must be some kind of formation , What data structure is such a queue ？

If shared resources are occupied , A certain blocking waiting wake mechanism is needed to ensure lock allocation . The main use of this mechanism is CLH A variant of the queue implements , Add the thread that can't get the lock temporarily to the queue , This queue is AQS The abstract expression of . It encapsulates threads that request shared resources as nodes of the queue （Node）, adopt CAS、 Spin and LockSupport.park() The way , maintain state The state of the variable , Make concurrency synchronous .

AQS preliminary

AQS First time to know

If there is a jam, you need to line up , Queue is necessary to realize queuing

AQS Use one volatile Of int Member variables of type to represent the synchronization state , Through the built-in FIFO Queue to complete the queuing work of resource acquisition, encapsulate each thread to preempt resources into a Node Node to achieve lock allocation , adopt CAS Finish right State Value modification .

AQS Internal architecture

AQS The basic structure of synchronization queue

CLH：Craig、Landin and Hagersten queue , It's a one-way linked list ,AQS The queue in is CLH Virtual two-way queues for variants （FIFO）

from ReentrantLock Reading AQS

Lock Implementation class of interface , Basically through 【 polymerization 】 One. 【 Queue synchronizer 】 The subclass of completes the thread access control

ReentrantLock Principle

From the simplest lock Methods start to look at fairness and unfairness

It can be clearly seen that fair lock and unfair lock lock() The only difference of the method is that the fair lock has a restriction when it obtains the synchronization state ：hasQueuedPredecessors()
hasQueuedPredecessors It is a method to judge whether there is an effective node in the waiting queue when a fair lock is applied

Not fair lock , Method lock()

Compare the of fair lock and unfair lock tryAcquire() Method implementation code , The difference is When an unfair lock obtains a lock, there is one less judgment than in a fair lock !hasQueuedPredecessors()

hasQueuedPredecessors() To determine whether to queue up , The differences between fair locks and unfair locks are as follows ：

Fair lock ： Fair lock pays attention to first come, first served , When a thread acquires a lock , If there is already a thread waiting in the waiting queue of this lock , Then the current thread will enter the waiting queue ;

Not fair lock ： Whether there is a waiting queue or not , If you can get the lock , Then immediately occupy the lock object . That is to say, the first queue thread of the queue is unpark(), After that, you still need to compete for the lock （ In case of thread contention ）