“This is the 24th day of my participation in the First Challenge 2022. For details: First Challenge 2022”
ReentrantLock
1.1 the characteristics of
ReentrantLock has the following features:
- reentrant
- interruptible
- You can set the timeout period
- Can be set to fair lock
- Conditional variable support
The realization principle of its characteristics will be explained in detail later.
1.2 Code Structure
Its code structure is shown as follows:
There are three inner classes: Sync, FairSync, and NonfairSync.
Sync inherited from AbstractQueuedSynchronizer.
AbstractQueuedSynchronizer Node and ConditionObject of two inner classes.
The literal meaning of the above class should give you a sense of where the aforementioned features are implemented.
Two, principle analysis
2.1 reentrant
Reentrant means that if the same thread first acquires the lock, it has the right to acquire it again because it is the owner of the lock. If it is a non-reentrant lock, then the second attempt to acquire it will itself be blocked by the lock.
Synchronized is also reentrant.
Examples of reentrant applications are as follows:
public class Test {
static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
method1();
}
public static void method1(a) {
lock.lock();
try {
System.out.println("method1");
method2();
} finally {
lock.unlock();
System.out.println("method1 unlock"); }}public static void method2(a) {
lock.lock();
try {
System.out.println("method2");
method3();
} finally {
lock.unlock();
System.out.println("method2 unlock"); }}public static void method3(a) {
lock.lock();
try {
System.out.println("method3");
} finally {
lock.unlock();
System.out.println("method3 unlock"); }}}Copy the codeResults:
method1
method2
method3
method3 unlock
method2 unlock
method1 unlock
Copy the codeNote that lock.unlock() must be on the first line of the finally block.
-
Source code analysis
Step by step, using the previous code:
Acquiring a lock
public void lock(a) { sync.lock(); } Copy the codeSync’s lock method has two implementation classes, fair and unfair:
An unfair lock is used here because NonfairLock is used by default when ReetrantLock is initialized:
public ReentrantLock(a) { sync = new NonfairSync(); } Copy the codeTo continue source tracking, the lock() method in an unfair lock:
final void lock(a) { // Use the spin lock here to determine whether the current thread holds the lock, and replace the value with 1 if it is 0 if (compareAndSetState(0.1)) // Set the lock to be exclusive to this thread setExclusiveOwnerThread(Thread.currentThread()); else // The comparison is not valid, try to obtain the lock acquire(1); } Copy the codeWhen a thread reenters or another thread attempts to acquire the lock, acquire(1) : setExclusiveOwnerThread () : setExclusiveOwnerThread () : setExclusiveOwnerThread () : setExclusiveOwnerThread () : setExclusiveOwnerThread ()
public final void acquire(int arg) { // Try to get the lock, if(! tryAcquire(arg) &&// With the short-circuit logic operator, when the fetch fails, the thread is added to the wait queue acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // Interrupt the current thread, actually set the interrupt flag selfInterrupt(); } Copy the codeLet’s focus on tryAcquire and see how to implement lock reentrant. Skip the intermediate process and look directly at the following code:
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); // Get the current thread synchronization status. State is volatile int c = getState(); // Indicates that no thread holds the lock if (c == 0) { // Spin lock, same process as before if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; }}// The current thread is the thread holding the lock else if (current == getExclusiveOwnerThread()) { // Add 1 to the current state int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); // Set the status value setState(nextc); return true; } return false; } Copy the codeUnlock: Unlock unlock: Unlock unlock
protected final boolean tryRelease(int releases) { // Get the current state minus 1 int c = getState() - releases; if(Thread.currentThread() ! = getExclusiveOwnerThread())throw new IllegalMonitorStateException(); boolean free = false; // The lock can be reentrant multiple times. The lock can only be released when the state is reduced to 0. if (c == 0) { free = true; setExclusiveOwnerThread(null); } setState(c); return free; } Copy the code
The principle of lock reentrant is fairly simple, so that’s it.
2.2 can disrupt
In addition to the regular lock() method, ReetrantLock provides a interruptible method, lockInterruptibly(), that will throw an exception if the thread holding the lock is interrupted while obtaining the lock:
public class InterruptTest {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
System.out.println("Start...");
try {
lock.lockInterruptibly();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("An interruption in the process of waiting for a lock.");
return;
}
try {
System.out.println("Got the lock.");
} finally{ lock.unlock(); }},"t1");
lock.lock();
System.out.println("Got the lock.");
t1.start();
try {
TimeUnit.SECONDS.sleep(1);
t1.interrupt();
System.out.println("Executive interruption");
} finally{ lock.unlock(); }}}Copy the codeResults:
Got the lock start... In the process of implementing interrupt lock was broken. Java lang. InterruptedException ats java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222) at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335) at com.cloud.bssp.juc.reetrantlock.InterruptTest.lambda$main$0(InterruptTest.java:19) at java.lang.Thread.run(Thread.java:748)Copy the codeIf the lock() method is used, even if the thread is interrupted, the lock can still be acquired and no exceptions will be thrown.
2.3 You can set the timeout period
ReetrantLock provides two methods to acquire the lock and return quickly, without waiting forever and returning immediately regardless of success or failure:
-
TryLock () When the lock is not held, the tryLock() method will immediately acquire the lock even if it is a fair lock, which is unfair but useful.
-
TryLock (long timeout, TimeUnit Unit) allows you to set a timeout period. Unlike tryLock, this method attempts to acquire the lock at the end of the timeout period. If it succeeds, it holds the lock and returns immediately. Cannot acquire a lock, in contrast to tryLock.
TryLock () test:
public class TryLockTest {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
if(! lock.tryLock()) { System.out.println("Lock acquisition failed");
return;
} else {
try {
System.out.println("Lock obtained successfully");
} finally{ lock.unlock(); }}}); lock.lock();try {
t1.start();
TimeUnit.SECONDS.sleep(1);
} finally{ lock.unlock(); }}}Copy the codeResults:
Failed to obtain the lockCopy the codeTimed tryLock() looks like this:
public class TryLockTimeTest {
public static void main(String[] args) throws InterruptedException {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
try {
if(! lock.tryLock(1, TimeUnit.SECONDS)) {
System.out.println("Waiting one second to acquire lock failed");
return;
} else {
try {
System.out.println("Wait one second to obtain lock success");
} finally{ lock.unlock(); }}}catch(InterruptedException e) { e.printStackTrace(); }}); lock.lock();try {
t1.start();
System.out.println("Wait two seconds.");
TimeUnit.SECONDS.sleep(2);
} finally{ lock.unlock(); }}}Copy the codeResults:
Wait two seconds Wait one second failed to obtain the lockCopy the code2.4 Setting a Fair lock
As mentioned earlier, ReentrantLock is unfair by default. Unfair is used because fair locks are generally unnecessary and reduce concurrency.
Create a fair lock as follows:
ReentrantLock lock = new ReentrantLock(true);
Copy the codeTracker constructor:
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
Copy the codeFocus on its fair lock implementation:
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock(a) {
// Inherit from AQS method, internal first call tryAcquire to obtain the lock, if the acquisition fails, add downtown to wait queue
acquire(1);
}
/** * Fair lock version of tryAcquire */
protected final boolean tryAcquire(int acquires) {
// Get the current thread
final Thread current = Thread.currentThread();
// Get the lock status
int c = getState();
// 0 indicates that the lock is not held
if (c == 0) {
// Check whether there are nodes waiting in the current wait queue
if(! hasQueuedPredecessors() &&// Compare and replace states
compareAndSetState(0, acquires)) {
// Set the current thread to an exclusive thread
setExclusiveOwnerThread(current);
return true; }}else if (current == getExclusiveOwnerThread()) {
// Lock reentrant
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false; }}Copy the code2.5 Conditional Variables
ReentrantLock supports multiple condition variables.
What to make of the above sentence? When we learned synchronized, we introduced its wait method. When a thread calls its wait method, it changes from the owner of the thread to the wait state and is added to the WaitSet of Monitor. When other threads call wait again, it is still added to the wait state. It’s like a common room.
ReentrantLock’s multiple condition variables are like multiple lounges.
ReentrantLock returns conditional variables using await()/signal() methods and conditionObject queues.
public class ConditionTest {
static ReentrantLock lock = new ReentrantLock();
static Condition Tom = lock.newCondition();
static Condition Jerry = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
try {
lock.lock();
Tom.await();
System.out.println("Eat the fish.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
try {
lock.lock();
Jerry.await();
System.out.println("Got the cheese.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
TimeUnit.SECONDS.sleep(1);
try {
lock.lock();
System.out.println("Here comes the fish.");
Tom.signal();
} finally {
lock.unlock();
}
TimeUnit.SECONDS.sleep(1);
try {
lock.lock();
System.out.println("Here comes the cheese");
Jerry.signal();
} finally{ lock.unlock(); }}}Copy the codeResults:
Fish came, fish came, cheese came, cheese cameCopy the codeAs shown above, there are several key points:
- Need to get lock before await
- The lock is released after await
- Call signal to wake up the thread, but also need to acquire the lock, otherwise an error will be reported. The awakened thread races again and continues execution from behind await.
- Remember unlock.
Now let’s focus on how to do that? Only the key methods are covered
Await method:
public final void await(a) throws InterruptedException {
// If the thread status is interrupted, an exception is thrown
if (Thread.interrupted())
throw new InterruptedException();
// Add the current thread to the conditional wait queue
Node node = addConditionWaiter();
// Release the lock
int savedState = fullyRelease(node);
int interruptMode = 0;
// When the node is not in a synchronous wait queue
while(! isOnSyncQueue(node)) {// Block the current thread
LockSupport.park(this);
if((interruptMode = checkInterruptWhileWaiting(node)) ! =0)
break;
}
// Get the wait queue lock without throwing an interrupt exception
if(acquireQueued(node, savedState) && interruptMode ! = THROW_IE)// Reset the interrupt flag
interruptMode = REINTERRUPT;
// Clear the cancelled node
if(node.nextWaiter ! =null)
unlinkCancelledWaiters();
// If the interrupt mode is not 0, the state determines whether to throw an exception, interrupt the thread or do nothing at all
if(interruptMode ! =0)
reportInterruptAfterWait(interruptMode);
}
Copy the codeAddConditionWaiter method:
private Node addConditionWaiter(a) {
// The last person waiting in conditionObject
Node t = lastWaiter;
// If the last wait is cancelled, clear it (not null, and the state is not waiting)
if(t ! =null&& t.waitStatus ! = Node.CONDITION) { unlinkCancelledWaiters(); t = lastWaiter; }// The node that sets the current thread to wait
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
Copy the codeMethod of signal:
public final void signal(a) {
// Determine if the thread holds the lock, and raise an exception if it does not
if(! isHeldExclusively())throw new IllegalMonitorStateException();
Node first = firstWaiter;
// If the first wait of the conditional queue is not null, signal wake up is performed
if(first ! =null)
doSignal(first);
}
Copy the codeDoSignal method
private void doSignal(Node first) {
do{if the next wait for the first node isnull
if ( (firstWaiter = first.nextWaiter) = =null)
// The last person waiting for the conditional queue is set to NULL
lastWaiter = null;
first.nextWaiter = null;
} while(! transferForSignal(first) && (first = firstWaiter) ! =null);
}
Copy the codeTransferForSignal method
final boolean transferForSignal(Node node) {
// Check whether the node status is condition, if it is 0, otherwise return false
if(! compareAndSetWaitStatus(node, Node.CONDITION,0))
return false;
/* * Add the node to the synchronous wait queue */
Node p = enq(node);
int ws = p.waitStatus;
// Here the wait state is 0, compare and replace the status with SIGNAL
if (ws > 0| |! compareAndSetWaitStatus(p, ws, Node.SIGNAL))// Unblock the thread
LockSupport.unpark(node.thread);
return true;
}
Copy the codeAbout ReentrantLock briefly introduced these, in fact, should first learn AQS, otherwise may not understand the source code.