当前位置：网站首页>AQS principle

AQS principle

2022-07-29 00:49:00 【51CTO】

AQS principle

1. summary

The full name is AbstractQueuedSynchronizer, yes Framework for blocking locks and associated synchronizer tools . Subclasses inherit it to implement synchronizers . The underlying implementation can refer to Monitor understand . Mainly through CAS and volitile maintain state So as to realize the lock of .

AQS principle _java

Source code display ：

AQS principle _java_02

characteristic ：

AQS It's an abstract class .AQS And its implementation class , Be similar to Monitor. Look at the second and third items below . however Monitor It's invisible , It's provided by the operating system .AQS yes Java adopt CAS and volitile The implementation is similar to Monitor The synchronizer .

use state Property to represent the state of the resource （ It can be divided into exclusive mode and shared mode ）, Subclasses need to define how to maintain this state , Controls how locks are acquired and released

getState - obtain state state
setState - Set up state state
compareAndSetState - cas Mechanism settings state state
Exclusive mode is that only one thread can access the resource , Shared mode allows multiple threads to access resources

Provides the basis for FIFO Wait queue to achieve blocking queue , Be similar to Monitor Of EntryList. There is one Node Inner class , Used to implement FIFO Waiting queue . Later on ReentrantLock When implementing the principle , Will introduce in detail .
Conditional variables to achieve waiting 、 Wake up mechanism , Support multiple conditional variables , Be similar to Monitor Of WaitSet. Use Lock.newCondition() Generate condition variables , The synchronizer is used at the bottom （ namely AQS Implementation class of ） newly build .

AQS principle _java_04

AQS Conditional variables in class

AQS principle _ Concurrent _05

Subclasses mainly implement such methods （ Default throw UnsupportedOperationException）

tryAcquire
tryRelease
tryAcquireShared
tryReleaseShared
isHeldExclusively

Get lock and release lock . Later on ReentrantLock When implementing the principle , Will introduce in detail .

Get lock pose

// If the lock acquisition fails
if (!tryAcquire(arg)) {
// The team , You can choose to block the current thread park unpark
}

Release lock posture

// If the lock is released successfully
if (tryRelease(arg)) {
// Let the blocked thread run again
}

2. Implement non reentrant locks

Custom synchronizer

AQS principle _java_02

       
       final 
       
       class 
       
       MySync 
       
       extends 
       
       AbstractQueuedSynchronizer {
       
       @Override
       
       protected 
       
       boolean 
       
       tryAcquire(
       
       int 
       
       acquires) {
       
       if (
       
       acquires 
       
       == 
       
       1){
       
       if (
       
       compareAndSetState(
       
       0, 
       
       1)) {
       
       setExclusiveOwnerThread(
       
       Thread.
       
       currentThread());
       
       return 
       
       true;
       
            }
       
        }
       
       return 
       
       false;
       
    }
       
       @Override
       
       protected 
       
       boolean 
       
       tryRelease(
       
       int 
       
       acquires) {
       
       if(
       
       acquires 
       
       == 
       
       1) {
       
       if(
       
       getState() 
       
       == 
       
       0) {
       
       throw 
       
       new 
       
       IllegalMonitorStateException();
       
            }
       
       setExclusiveOwnerThread(
       
       null);
       
       setState(
       
       0);
       
       return 
       
       true;
       
        }
       
       return 
       
       false;
       
    }
       
       protected 
       
       Condition 
       
       newCondition() {
       
       return 
       
       new 
       
       ConditionObject();
       
    }
       
       @Override
       
       protected 
       
       boolean 
       
       isHeldExclusively() {
       
       return 
       
       getState() 
       
       == 
       
       1;
       
    }}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.

Custom Lock

With a custom synchronizer , It's easy to reuse AQS , Implement a fully functional Custom Lock .

according to lock Method we can see the synchronizer sync amount to monitor, Similar to monitor Of EntryList Waiting queue .

       
       class 
       
       MyLock 
       
       implements 
       
       Lock {
       
       static 
       
       MySync 
       
       sync 
       
       = 
       
       new 
       
       MySync();
       
       @Override
       
       //  Try , You don't succeed , Enter the waiting queue 
       
       public 
       
       void 
       
       lock() {
       
       sync.
       
       acquire(
       
       1);    
       
       //acquire The method is AQS Methods 
       
    }
       
       @Override
       
       //  Try , You don't succeed , Enter the waiting queue , Can interrupt 
       
       public 
       
       void 
       
       lockInterruptibly() 
       
       throws 
       
       InterruptedException {
       
       sync.
       
       acquireInterruptibly(
       
       1);
       
    }
       
       @Override
       
       //  Try it once , Unsuccessful return , Not in the queue 
       
       public 
       
       boolean 
       
       tryLock() {
       
       return 
       
       sync.
       
       tryAcquire(
       
       1);
       
    }
       
       @Override
       
       //  Try , You don't succeed , Enter the waiting queue , Time limited 
       
       public 
       
       boolean 
       
       tryLock(
       
       long 
       
       time, 
       
       TimeUnit 
       
       unit) 
       
       throws 
       
       InterruptedException {
       
       return 
       
       sync.
       
       tryAcquireNanos(
       
       1, 
       
       unit.
       
       toNanos(
       
       time));
       
    }
       
       @Override
       
       //  Release the lock 
       
       public 
       
       void 
       
       unlock() {
       
       sync.
       
       release(
       
       1);
       
    }
       
       @Override
       
       //  Generate condition variables 
       
       public 
       
       Condition 
       
       newCondition() {
       
       return 
       
       sync.
       
       newCondition();
       
    }
       
}
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.

test ：

       
       MyLock 
       
       lock 
       
       = 
       
       new 
       
       MyLock();
       
       new 
       
       Thread(() 
       
       -> {
       
       lock.
       
       lock();    
       
       // To be successful , Get into AQS Implementation class of MySync Synchronizer becomes Owner Threads 
       
       try {
       
       log.
       
       debug(
       
       "locking...");
       
       sleep(
       
       1);
       
            } 
       
       finally {
       
       log.
       
       debug(
       
       "unlocking...");
       
       lock.
       
       unlock();
       
            }
       
        },
       
       "t1").
       
       start();
       
       new 
       
       Thread(() 
       
       -> {
       
       lock.
       
       lock();        
       
       // Acquisition failure ,MySync Create a blocking queue , take t2 Thread into queue .
       
       try {
       
       log.
       
       debug(
       
       "locking...");
       
            } 
       
       finally {
       
       log.
       
       debug(
       
       "unlocking...");
       
       lock.
       
       unlock();
       
            }
       
        },
       
       "t2").
       
       start();
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

NonfairSync Inherited from AQS. Let's take a look , More on that later .

AQS principle _jvm_11

Output ：

22:29:28.727 c.TestAqs [t1] - locking...
22:29:29.732 c.TestAqs [t1] - unlocking...
22:29:29.732 c.TestAqs [t2] - locking...
22:29:29.732 c.TestAqs [t2] - unlocking...

Non reentrant test
If you change to the following code , You will find yourself blocked （ Only print once locking）

lock.lock();
log.debug("locking...");
lock.lock();
log.debug("locking...");

3. Experience

origin

Early programmers would use one synchronizer to implement another similar synchronizer , For example, a reentrant lock is used to implement a semaphore , Or vice versa . It's obviously not elegant enough , therefore stay JSR166（java Specification proposal ） Created in AQS, This general synchronizer mechanism is provided .

The goal is

AQS Functional objectives to be achieved

Blocking version acquisition lock acquire And non blocking versions try to get locks tryAcquire( If the attempt fails, it will not enter the waiting queue )
Get lock timeout mechanism
By interrupting the cancellation mechanism
Exclusive mechanism and sharing mechanism
Waiting mechanism when conditions are not met

Performance goals to achieve

Instead, the primary performance goal here is scalability: to predictably maintain efficiency even, or especially, when synchronizers are contended
contrary , The main performance goal here is scalability : When competing for synchronizer , Maintain efficiency predictably .

Design

AQS The basic idea of is actually very simple

The logic of acquiring lock

while(state Status does not allow getting ) {
if( This thread is not in the queue yet ) {
Join the team and block
}
}
The current thread is out of the queue

Logic of releasing lock

if(state Status allows ) {
Recover blocked threads (s)
}
unpark Indicates to wake up the next thread . I'll give you a detailed introduction later .

The main points of

        ● Atomic maintenance state state （ adopt CAS and volitile）
        ● Blocking and resuming threads
        ● Maintenance queue

1) state Design

state Use volatile coordination cas Ensure the atomicity of its modification .
state Used 32bit int To maintain the synchronization state , Because... Was used long The test results on many platforms are not ideal .

2) Blocking recovery design

Early control threads pause and resume api Yes suspend and resume, But they are not available , Because if you call first resume, that suspend Will not feel
The solution is to use park & unpark To pause and resume threads , The specific principle has been mentioned before , First unpark Again park Also no problem
park & unpark It's about threads , Not for the synchronizer , Therefore, the control granularity is more fine
park Threads can also pass through interrupt interrupt

3) Queue design

Used FIFO First in, first out , To realize the waiting queue （ Be similar to Monitor Of EntryList） And conditional variables . Priority queues are not supported .
The design draws on CLH（ Synchronous queue ） queue , It is a one-way lockless queue .

In the queue head and tail Two pointer nodes , Use both volatile Decorate with cas Use , Every Node Yes state Maintain node status .

After joining and leaving the team, we will introduce in detail .
Queue pseudo code , Just think about it tail Atomicity of assignment .

AQS principle _java_15

Outgoing pseudo code

AQS principle _ide_16

CLH benefits ：

unlocked , Use spin
Fast , Non blocking

AQS Improved in some ways CLH

       
       private 
       
       Node 
       
       enq(
       
       final 
       
       Node 
       
       node) {
       
       for (;;) {
       
       Node 
       
       t 
       
       = 
       
       tail;
       
       //  There are no elements in the queue  tail  by  null
       
       if (
       
       t 
       
       == 
       
       null) {
       
       //  take  head  from  null -> dummy
       
       if (
       
       compareAndSetHead(
       
       new 
       
       Node()))
       
       tail 
       
       = 
       
       head;
       
            } 
       
       else {
       
       //  take  node  Of  prev  Set to the original  tail
       
       node.
       
       prev 
       
       = 
       
       t;
       
       //  take  tail  From the original  tail  Set to  node
       
       if (
       
       compareAndSetTail(
       
       t, 
       
       node)) {
       
       //  original  tail  Of  next  Set to  node
       
       t.
       
       next 
       
       = 
       
       node;
       
       return 
       
       t;
       
                }
       
            }
       
        }
       
    }
      
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.