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

Editor to share with you the Java concurrent J.U.C AQS:CLH synchronization queue example analysis, I believe that most people do not know much about it, so share this article for your reference, I hope you will learn a lot after reading this article, let's go to know it!

The CLH synchronization queue is a FIFO two-way queue, and AQS relies on it to manage the synchronization status. If the current thread fails to obtain the synchronization status, AQS will construct a node (Node) and add it to the CLH synchronization queue with information such as the waiting status of the current thread. At the same time, it will block the current thread. When the synchronization state is released, it will wake up the first node (fair lock) and make it try to obtain the synchronization status again.

In the CLH synchronization queue, a node represents a thread that holds the thread's reference (thread), state (waitStatus), precursor node (prev), and successor node (next), which are defined as follows:

Static final class Node {/ * * sharing * / static final Node SHARED = new Node (); / * * exclusive * / static final Node EXCLUSIVE = null; / * because of timeout or interruption, the node will be set to cancel, and the canceled node will not participate in the competition. It will always keep the canceled state and will not change to other states. * / static final int CANCELLED = 1; / * the thread of the successor node is waiting, and if the thread of the current node releases the synchronization state or is cancelled, it will notify the successor node, so that the thread of the successor node can run * / static final int SIGNAL =-1 / * the node is in the waiting queue, and the node thread is waiting on the Condition. When other threads call signal () on the Condition, the changed node will be transferred from the waiting queue to the synchronization queue and added to the synchronization state acquisition * / static final int CONDITION =-2; / * indicates that the next shared synchronization state acquisition will be propagated unconditionally * / static final int PROPAGATE =-3 / * * waiting status * / volatile int waitStatus; / * * precursor node * / volatile Node prev; / * * successor node * / volatile Node next; / * * Thread / volatile Thread thread; Node nextWaiter; final boolean isShared () {return nextWaiter = = SHARED;} final Node predecessor () throws NullPointerException {Node p = prev; if (p = null) throw new NullPointerException (); else return p } Node () {} Node (Thread thread, Node mode) {this.nextWaiter = mode; this.thread = thread;} Node (Thread thread, int waitStatus) {this.waitStatus = waitStatus; this.thread = thread;}}

The structure of the CLH synchronization queue is as follows:

Join the list

For those of us who have learned the data structure, the listing of the CLH team is nothing more simple than that the tail points to the new node, the prev of the new node points to the current last node, and the next of the current last node points to the current node. For the code, we can look at the addWaiter (Node node) method:

Private Node addWaiter (Node mode) {/ / New Node Node node = new Node (Thread.currentThread (), mode); / / Quick attempt to add tail node Node pred = tail; if (pred! = null) {node.prev = pred; / / CAS set tail node if (compareAndSetTail (pred, node)) {pred.next = node; return node;}} / / multiple attempts enq (node); return node;}

AddWaiter (Node node) first makes a quick attempt to set the tail node, and if it fails, call the enq (Node node) method to set the tail node

Private Node enq (final Node node) {/ / several attempts until for (;;) {Node t = tail; / / tail does not exist, set to if (t = = null) {if (compareAndSetHead (new Node () tail = head;} else {/ / set to tail node node.prev = t; if (compareAndSetTail (t, node)) {t.next = node; return t;}

In the above code, both methods set the tail node through a CAS method compareAndSetTail (Node expect, Node update), which ensures that the node is thread-safe to add. In the enq (Node node) method, AQS uses a "dead loop" to ensure that nodes can be added correctly, and the current thread will not return from this method until it is added successfully, otherwise it will continue to execute.

The process diagram is as follows:

Out of line

The CLH synchronization queue follows FIFO. After the thread of the first node releases the synchronization state, it will wake up its successor node (next), and the successor node will set itself as the head node when the synchronization status is obtained successfully. This process is very simple. Head executes the node and disconnects the next of the original head node and the prev of the current node. Note that CAS is not needed to guarantee this process. Because only one thread can successfully get the synchronization state. The process diagram is as follows:

The above is all the contents of the article "sample Analysis of AQS:CLH synchronization queues for Java concurrent J.U.C". Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

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.