“This is the 30th day of my participation in the First Challenge 2022. For details: First Challenge 2022”
ReentrantReadWriteLock ReentrantReadWriteLock ReentrantReadWriteLock
When the read operation is much higher than the write operation, the read-write lock can be used to enable read-read concurrency and improve performance.
Summary: Improve performance by reducing the granularity of locks. No matter what, even distributed lock, the finer the granularity, the smaller the performance loss caused by it, I don’t know if we can understand it?
This article is based on the form of source code, I hope students can take this as the idea, track the source code step by step debug into, deepen understanding.
First introduction to ReentrantReadWriteLock
Again, take a look at the class diagram:
- Realize read and write lock interface
ReadWriteLock - There are five inner classes, the same as ReentrantLock
FairSync,NonfairSyncandSyncAdd two inner classes, both of which implement the Lock interface:WriteLockReadLock
- Sync adds two inner classes:
HoldCounter: the counter that holds the lockThreadLocalHoldCounter: Maintains the ThreadLocal of a HoldCounter
Ii. Use cases
A container class that operates on data is usually maintained, and should encapsulate the read and write methods of the data, as follows:
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/ * * *@description: data container class *@author: weirx *@date: 2022/1/13 days *@version: 3.0 * /
public class DataContainer {
/** * Initializes read and write locks */
private ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
private ReentrantReadWriteLock.ReadLock readLock = reentrantReadWriteLock.readLock();
private ReentrantReadWriteLock.WriteLock writeLock = reentrantReadWriteLock.writeLock();
protected void read(a){
readLock.lock();
try {
System.out.println("Get read lock");
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
readLock.unlock();
System.out.println("Release read lock"); }}protected void write(a){
writeLock.lock();
try {
System.out.println("Get write lock");
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
writeLock.unlock();
System.out.println("Release write lock"); }}}Copy the codeSimple test, divided into reading, reading, writing.
- Read:
public static void main(String[] args) {
// Initialize the data container
DataContainer dataContainer = new DataContainer();
new Thread(() -> {
dataContainer.read();
}, "t1").start();
new Thread(() -> {
dataContainer.read();
}, "t2").start();
}
Copy the codeAs a result, read is not mutually exclusive, and the read lock is acquired and released simultaneously:
Obtain the read lock Obtain the read lock Release the read lock Release the read lockCopy the code- Reading and writing:
public static void main(String[] args) {
// Initialize the data container
DataContainer dataContainer = new DataContainer();
new Thread(() -> {
dataContainer.read();
}, "t1").start();
new Thread(() -> {
dataContainer.write();
}, "t2").start();
}
Copy the codeAs a result, read and write are mutually exclusive, and either the read or write methods are executed first, until the read or write lock is released before the next lock is acquired:
Acquire the read lock -- the first execution releases the read lock -- the second execution acquires the write lock -- the third execution releases the write lock -- the fourth executionCopy the code- Write about:
public static void main(String[] args) {
// Initialize the data container
DataContainer dataContainer = new DataContainer();
new Thread(() -> {
dataContainer.write();
}, "t1").start();
new Thread(() -> {
dataContainer.write();
}, "t2").start();
}
Copy the codeAs a result, writes are mutually exclusive, and the next write lock cannot be acquired until the first is released:
Obtain write lock Release Write lock Obtain write lock release write lockCopy the codeNote:
- When a lock is reentered, the write lock is kept waiting after the read lock is obtained
protected void read(a){ readLock.lock(); try { System.out.println("Get read lock"); TimeUnit.SECONDS.sleep(1); System.out.println("Get write lock"); writeLock.lock(); } catch (InterruptedException e) { e.printStackTrace(); } finally { readLock.unlock(); System.out.println("Release read lock"); }}Copy the codeResult: No release
Obtain read lock Obtain write lockCopy the code - When a lock is reentered, the write lock is held and the read lock can be acquired again.
protected void write(a){ writeLock.lock(); try { System.out.println("Get write lock"); TimeUnit.SECONDS.sleep(1); System.out.println("Get read lock"); readLock.lock(); } catch (InterruptedException e) { e.printStackTrace(); } finally { writeLock.unlock(); System.out.println("Release write lock"); }}Copy the codeResults:
Obtain write lock Obtain read lock release write lockCopy the code
Third, source code analysis
According to the previous example, from the read lock to release, from the write lock to release, look at the source code.
Note that read-write locks use different bits to distinguish the state of an exclusive lock from that of a shared lock:
/* * Read and write are divided into two parts, the lower 16 bits are in the exclusive lock state, and the higher 16 bits are in the shared lock state */
static final int SHARED_SHIFT = 16;
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
/** Returns the number of shares held in count */
static int sharedCount(int c) { return c >>> SHARED_SHIFT; }
/** returns the number of mutex holds represented by count */
static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }
Copy the code3.1 Read Lock Analysis
3.1.1 Obtaining read locks
The lock (); from readLock. Here comes the analysis:
/** * get read lock. * If the write lock is not held by another thread, the read lock is acquired and returned immediately. * If the write lock is held by another thread, the current thread is disabled for thread scheduling purposes and sleeps until the read lock is acquired */
public void lock(a) {
sync.acquireShared(1);
}
Copy the codeAs method of the lock is ReentrantReadWriteLock subclasses ReadLock methods, and acquireShared method is defined in a subclass of AQS Syn, this method attempts to obtain in the form of Shared read locks, failure, into the waiting queue, retry, Until the read lock is acquired.
public final void acquireShared(int arg) {
// If held by another thread, go to doAcquireShared of AQS
if (tryAcquireShared(arg) < 0)
// Obtain the shared lock. If the lock fails, join the waiting queue
doAcquireShared(arg);
}
Copy the codeTryAcquireShared is implemented in ReentrantReadWriteLock.
protected final int tryAcquireShared(int unused) {
// Get the current thread
Thread current = Thread.currentThread();
// Get the current lock status
int c = getState();
// If the exclusive lock count is not equal to 0 and the owner is not the current thread, return -1, in other words, held by another thread
if(exclusiveCount(c) ! =0&& getExclusiveOwnerThread() ! = current)return -1;
// Number of shared locks
int r = sharedCount(c);
// Return fase to qualify for the read lock
if(! readerShouldBlock() &&// The number of holdings is smaller than the default value
r < MAX_COUNT &&
// CAS sets the lock status
compareAndSetState(c, c + SHARED_UNIT)) {
// Hold the shared lock to 0
if (r == 0) {
// The first holder is the current thread
firstReader = current;
// The total number of holds is 1
firstReaderHoldCount = 1;
} else if (firstReader == current) {
// The current thread holds the lock
firstReaderHoldCount++;
} else {
// Get the cache count
HoldCounter rh = cachedHoldCounter;
// If it is null or the id of the holding thread is not the current thread
if (rh == null|| rh.tid ! = getThreadId(current))// Assign to the cache
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
// if rh is not null and is the current thread, set the read lock holder to the value in the cache
readHolds.set(rh);
// Add + 1
rh.count++;
}
return 1;
}
// The thread that wants to acquire the read lock should block, doing bottom line work, handling failed CAS hits and unprocessed reentrant reads in tryAcquireShared
return fullTryAcquireShared(current);
}
Copy the codeWe can see from the above source, write lock and read lock is mutually exclusive.
3.1.2 Release of read lock
Get right to the point
/** * Release lock in shared mode, tryReleaseShared returns true, release */
public final boolean releaseShared(int arg) {
/ / releases the lock
if (tryReleaseShared(arg)) {
// Wake up the next thread in the queue
doReleaseShared();
return true;
}
return false;
}
Copy the codeTake a look at the tryReleaseShared implementation of read/write locks:
protected final boolean tryReleaseShared(int unused) {
/ /... Omit...
for (;;) {
int c = getState();
int nextc = c - SHARED_UNIT;
if (compareAndSetState(c, nextc))
// The count of read locks does not affect other read lock threads, but does affect other write lock threads
// The count is 0
return nextc == 0; }}Copy the codeIf the above method is released successfully, the following AQS inherited method is used:
private void doReleaseShared(a) {
// If head.waitStatus == Node.SIGNAL ==> 0 succeeds, the next Node is unpark
// If head.waitStatus == 0 ==> PROPAGATE
for (;;) {
Node h = head;
if(h ! =null&& h ! = tail) {int ws = h.waitStatus;
// If another thread is releasing the read lock, change waitStatus to 0 first
// Prevent the unparksucceeded from being repeated
if (ws == Node.SIGNAL) {
if(! compareAndSetWaitStatus(h, Node.SIGNAL,0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
// If it is already 0, change it to -3
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break; }}Copy the code3.2 Write lock Analysis
3.2.1 acquiring a lock
public final void acquire(int arg) {
// Failed to obtain the write lock
if(! tryAcquire(arg) &&// Associate the current thread to a Node object in exclusive mode
// The AQS queue is blockedacquireQueued(addWaiter(Node.EXCLUSIVE), arg) ) { selfInterrupt(); }}Copy the codeRead/write lock lock method: tryAcquire
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
// Get the low 16 bits, representing the state count of the write lock
int w = exclusiveCount(c);
if(c ! =0) {
// If the write lock is 0 or the current thread is not equal to the exclusive thread, the acquisition fails
if (w == 0|| current ! = getExclusiveOwnerThread())return false;
// Write lock count exceeds the lower 16 bits, an exception is reported
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Write the lock to reenter
setState(c + acquires);
return true;
}
// Write locks should block
if (writerShouldBlock() ||
// Failed to change count! compareAndSetState(c, c + acquires))// Failed to obtain the lock
return false;
// Set the current thread exclusive lock
setExclusiveOwnerThread(current);
return true;
}
Copy the code3.2.2 releases the lock
Release:
public final boolean release(int arg) {
// Attempted to release the write lock successfully
if (tryRelease(arg)) {
Node h = head;
if(h ! =null&& h.waitStatus ! =0)
unparkSuccessor(h);
return true;
}
return false;
}
Copy the codeTryRelease:
protected final boolean tryRelease(int releases) {
if(! isHeldExclusively())throw new IllegalMonitorStateException();
int nextc = getState() - releases;
// Because of reentrancy, the write lock count is 0 to be released successfully
boolean free = exclusiveCount(nextc) == 0;
if (free) {
setExclusiveOwnerThread(null);
}
setState(nextc);
return free;
}
Copy the codeIn jdK1.8, StampedLock is also introduced to use StampedLock with stamps to further improve performance. This article is not enough introduction, interested students to collect relevant information to learn.
To learn more about concurrent programming, check out the following column: juejin.cn/column/7050…