Shulou(Shulou.com)06/01 Report--

This article mainly introduces the relevant knowledge of "how to understand the reentrant lock ReentrantLock in Java multithreading". The editor shows you the operation process through an actual case. The method of operation is simple and fast, and it is practical. I hope this article "how to understand the reentrant lock ReentrantLock in Java multithreading" can help you solve the problem.

Preface

There are many ways to ensure thread safety, such as CAS operation, synchronized, atomic class, volatile guaranteed visibility, ReentrantLock and so on. This paper describes ReentrantLock based on JDK1.8.

1. Reentrant lock

The so-called reentrant lock means that a thread has acquired a lock, and when the thread wants to acquire the lock again, it can still acquire success without deadlock. Synchronized is a reentrant lock. In addition, the ReentrantLock provided by JDK is also a reentrant lock.

2. Simple use of ReentrantLock2.1 ReentrantLock public class TestReentrantLock {private static int i = 0; public static void main (String [] args) {ReentrantLock lock = new ReentrantLock (); try {lock.lock (); iTunes;} finally {lock.unlock ();} System.out.println (I) }}

The above is a simple usage case list of ReentrantLock. Before entering the synchronous code block, you need to call the lock () method to add the lock. After executing the synchronous code block, in order to prevent the deadlock caused by an exception, you need to call the unlock () method in the finally block to unlock it.

2.2 ReentrantLock UML figure 2.3 lock () method call chain

The figure above depicts the method invocation process of ReentrantLock.lock () locking. There is a member variable private final Sync sync,Sync in ReentrantLock that is a subclass of AQS. In the lock () method of ReentrantLock, the lock () method of sync is called, which is an abstract method, specifically calling the lock () method implemented in NonfairSync:

/ * Performs lock. Try immediate barge, backing up to normal * acquire on failure. * / final void lock () {if (compareAndSetState (0,1)) setExclusiveOwnerThread (Thread.currentThread ()); else acquire (1);}

In this method, you first try to lock through the CAS operation. If locking fails, the acquire () method of AQS is called:

/ * Acquires in exclusive mode, ignoring interrupts. Implemented * by invoking at least once {@ link # tryAcquire}, * returning on success. Otherwise the thread is queued, possibly * repeatedly blocking and unblocking, invoking {@ link * # tryAcquire} until success. This method can be used * to implement method {@ link Lock#lock}. * * @ param arg the acquire argument. This value is conveyed to * {@ link # tryAcquire} but is otherwise uninterpreted and * can represent anything you like. * / public final void acquire (int arg) {if (! tryAcquire (arg) & & acquireQueued (addWaiter (Node.EXCLUSIVE), arg) selfInterrupt ();}

In the acquire method of AQS, first try to call the tryAcquire method to lock. If it fails, acquireQueued will be called to enter the waiting queue. The acquireQueued method will be explained in Chapter 3. Let's first look at the content of the tryAcquire method. The tryAcquire method of AQS is a template method, which is implemented in the tryAcquire method of NonfairSync, in which only the nonfairTryAcquire method is called:

/ * Performs non-fair tryLock. TryAcquire is implemented in * subclasses, but both need nonfair try for trylock method. * / final boolean nonfairTryAcquire (int acquires) {final Thread current = Thread.currentThread (); int c = getState (); if (c = = 0) {if (compareAndSetState (0, acquires)) {setExclusiveOwnerThread (current); return true;}} else if (current = = getExclusiveOwnerThread ()) {int nextc = c + acquires If (nextc < 0) / / overflow throw new Error ("Maximum lock count exceeded"); setState (nextc); return true;} return false;}

In this method, you first get the state to determine whether it is 0 or not. If 0 means that no other thread occupies the lock, it will try to lock it by setting state to 1 through the CAS operation; if state is not 0, it means that a thread has already occupied the lock and determines whether the thread occupying the lock is the current thread. If so, add state to the operation, which is the principle of ReentrantLock reentrant implementation.

III. AQS

AQS is AbstractQueuedSynchronizer. AQS provides a FIFO-based queue that can be used to build the infrastructure for locks or other related synchronization devices. AQS is actually a variant of CLH (Craig,Landin,Hagersten) lock. Let's explain the core idea of AQS and its implementation.

3.1 state/** * The synchronization state. * / private volatile int state

State is the core member variable in AQS. This is a volatile variable, and when it is 0, it means that no thread is occupying the lock. The thread locks the state from 0 to 1 through CAS. When the thread holds the lock and locks it again, the state will be added 1, that is, reentry.

3.2 exclusiveOwnerThread/** * The current owner of exclusive mode synchronization. * / private transient Thread exclusiveOwnerThread

ExclusiveOwnerThread is a member variable in the parent class AbstractOwnableSynchronizer of AQS, which is used to determine whether the thread holding the lock is the current thread when implementing the reentrant mechanism.

3.3 AQS waiting queue

In addition to the above two important member variables, state and exclusiveOwnerThread, AQS maintains a waiting queue. When a thread fails to try to add a lock, it enters the waiting queue, which is the core of the entire AQS. The waiting queue is a two-way linked list whose node Node encapsulates the thread waiting to be locked.

/ * Creates and enqueues node for current thread and given mode. * * @ param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared * @ return the new node * / private Node addWaiter (Node mode) {Node node = new Node (Thread.currentThread (), mode); / / Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred! = null) {node.prev = pred / append yourself to the tail of the linked list if (compareAndSetTail (pred, node)) {pred.next = node; return node;}} enq (node); return node;} by CAS operation

When a thread fails in its attempt to lock, it appends itself to the end of the linked list through the CAS operation. After joining the queue, acquireQueued is called to try to lock the queue:

/ * * Acquires in exclusive uninterruptible mode for thread already in * queue. Used by condition wait methods as well as acquire. * * @ param node the node * @ param arg the acquire argument * @ return {@ code true} if interrupted while waiting * / final boolean acquireQueued (final Node node, int arg) {boolean failed = true; try {boolean interrupted = false; for (;) {final Node p = node.predecessor () If (p = = head & & tryAcquire (arg)) {setHead (node); p.next = null; / / help GC failed = false; return interrupted } if (shouldParkAfterFailedAcquire (p, node) & & parkAndCheckInterrupt () interrupted = true;}} finally {if (failed) cancelAcquire (node);}}

In this method, it is determined whether its front node is a header node, and if so, an attempt is made to lock it. If locking fails, the LockSupport.park method is called to enter the blocking state and wakes up after its predecessor node releases the lock.

3.4 template method design patterns in AQS

AQS perfectly uses the template method design pattern, which defines a series of template methods. Such as the following methods:

/ / use in mutex mode: try to acquire lock protected boolean tryAcquire (int arg) {throw new UnsupportedOperationException ();} / / use in mutex mode: try to release lock protected boolean tryRelease (int arg) {throw new UnsupportedOperationException ();} / / use in shared mode: try to acquire lock protected int tryAcquireShared (int arg) {throw new UnsupportedOperationException () } / / use in shared mode: try to release lock protected boolean tryReleaseShared (int arg) {throw new UnsupportedOperationException ();}

These methods only throw UnsupportedOperationException exceptions in AQS, so subclasses are needed to implement them. These methods are not designed as abstract methods because subclasses of AQS may only need to implement some of these methods to implement their functions.

This is the end of the introduction to "how to understand the reentrant lock ReentrantLock in Java multithreading". Thank you for reading. If you want to know more about the industry, you can follow the industry information channel. The editor will update different knowledge points for you every day.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.