The source code of this article is based on JDK13

## ConcurrentLinkedQueue

### Official annotation translation

An unbounded thread safe queue implemented with a linked list. This queue provides the element order of FIFO

When multiple threads need to share access to a collection, ConcurrentLinkedQueue is an appropriate choice. Like other concurrent collection implementations, this class does not accept null elements

This implementation uses an efficient lock free algorithm. It comes from paper Simple, Fast, and Practical Non-Blocking and Blocking Concurrent Queue Algorithms

The iterator is weakly synchronous, and the returned element is the element snapshot when the iterator is created. The ConcurrentModificationException will not be thrown. It can be carried out concurrently with other operations. The element when the iterator is created will be returned exactly once

It should be noted that, unlike most other collections, the size method is not a constant time operation. Because of the asynchronous nature of the queue, counting the current elements requires traversing all elements. Therefore, if other threads are changing, the size method may return inaccurate numbers

Batch operations do not guarantee atomicity, such as addAll. When foreach and addAll run together, foreach may only observe some elements

This class and its Iterator implement all the optional methods of Queue and Iterator

### Source code

#### definition

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E> implements Queue<E>, java.io.Serializable {

This is a queue

#### struct Node

static final class Node<E> { volatile E item; volatile Node<E> next; /** * Constructs a node holding item. Uses relaxed write because * item can only be seen after piggy-backing publication via CAS. */ Node(E item) { ITEM.set(this, item); } /** Constructs a dead dummy node. */ Node() {} void appendRelaxed(Node<E> next) { // assert next != null; // assert this.next == null; NEXT.set(this, next); } boolean casItem(E cmp, E val) { // assert item == cmp || item == null; // assert cmp != null; // assert val == null; return ITEM.compareAndSet(this, cmp, val); } }

It saves the data Item of the current node and the pointer to the next node next

Two cas methods are provided to change data and pointer respectively

#### attribute

transient volatile Node<E> head; private transient volatile Node<E> tail;

Saved the head and tail nodes of the linked list

#### Construction method

public ConcurrentLinkedQueue() { head = tail = new Node<E>(); } public ConcurrentLinkedQueue(Collection<? extends E> c) { Node<E> h = null, t = null; for (E e : c) { Node<E> newNode = new Node<E>(Objects.requireNonNull(e)); if (h == null) h = t = newNode; else t.appendRelaxed(t = newNode); } if (h == null) h = t = new Node<E>(); head = h; tail = t; }

Two construction methods are provided to support the creation of empty queues and the initialization of all given collections into queues

#### Join method offer

public boolean add(E e) { return offer(e); } public boolean offer(E e) { // Create a new node final Node<E> newNode = new Node<E>(Objects.requireNonNull(e)); for (Node<E> t = tail, p = t;;) { Node<E> q = p.next; // The next of the tail node is empty. The cas is updated directly and successfully if (q == null) { // p is last node if (NEXT.compareAndSet(p, null, newNode)) { // Successful CAS is the linearization point // for e to become an element of this queue, // and for newNode to become "live". if (p != t) // hop two nodes at a time; failure is OK TAIL.weakCompareAndSet(this, t, newNode); return true; } // Lost CAS race to another thread; re-read next } // The p node is deleted, that is, out of the queue. Reset the value of the p node else if (p == q) // We have fallen off list. If tail is unchanged, it // will also be off-list, in which case we need to // jump to head, from which all live nodes are always // reachable. Else the new tail is a better bet. p = (t != (t = tail)) ? t : head; else // Check for tail updates after two hops. // If the tail node is updated elsewhere, see whether you should continue to look back or not p = (p != t && t != (t = tail)) ? t : q; } }

The offer method performs the actual addition operation, linking the given node to the tail of the existing queue. In the process, full consideration should be given to the competition with other threads

#### Outgoing method poll

public E poll() { restartFromHead: for (;;) { for (Node<E> h = head, p = h, q;; p = q) { // Start at the head of the team final E item; // If the team leader is OK, directly update the cas and return the result if ((item = p.item) != null && p.casItem(item, null)) { // Successful CAS is the linearization point // for item to be removed from this queue. if (p != h) // hop two nodes at a time updateHead(h, ((q = p.next) != null) ? q : p); return item; } // The next header node is empty and the queue is empty else if ((q = p.next) == null) { updateHead(h, p); return null; } // The current node is out of the team. Start from the team head again else if (p == q) continue restartFromHead; } } }

Start traversing from the queue head. If the header node is successfully obtained and the CAS update is successful, it will return. Otherwise, continue to find the next node

#### View team leader peek

public E peek() { restartFromHead: for (;;) { for (Node<E> h = head, p = h, q;; p = q) { final E item; // Queue header element OK. Returns the queue header element if ((item = p.item) != null || (q = p.next) == null) { updateHead(h, p); return item; } // The current node is out of the queue. Find the team leader again else if (p == q) continue restartFromHead; } } }

Relatively simple, keep trying to get the team head element

#### View quantity size

public int size() { restartFromHead: for (;;) { int count = 0; // Start counting from the head of the team for (Node<E> p = first(); p != null;) { if (p.item != null) if (++count == Integer.MAX_VALUE) break; // @see Collection.size() // The current element is out of the queue. Count from the beginning if (p == (p = p.next)) continue restartFromHead; } return count; } }

Count from the head of the team every time. If the middle and double opening are changed by others, count from the head of the team again

#### summary

A non - blocking, thread - safe queue with no lock in the whole process is implemented by CAS + spin

## Reference articles

End.

## Contact me

Finally, welcome to my personal official account, Yan Yan ten, which will update many learning notes from the backend engineers. I also welcome direct official account or personal mail or email to contact me.

The above are all personal thoughts. If there are any mistakes, please correct them in the comment area.

Welcome to reprint, please sign and keep the original link.

Contact email: huyanshi2580@gmail.com

For more study notes, see personal blog or WeChat official account, Yan Yan ten > > Huyan ten