ConcurrentLinkedQueue in Java

ConcurrentLinkedQueue is a high-performance, thread-safe, non-blocking queue in Java.

It belongs to the java.util.concurrent package and is widely used for multi-threaded producer–consumer systems.

It uses a lock-free algorithm based on CAS (Compare-And-Swap), making it extremely fast in concurrent environments.

---

What is ConcurrentLinkedQueue?

A ConcurrentLinkedQueue is:

• A thread-safe, unbounded, non-blocking queue
• Based on a linked-node structure
• Follows FIFO (First In First Out) order
• Supports multiple threads inserting/removing simultaneously
• Uses lock-free CAS for high-speed operations

It is one of the most scalable queues in the JDK.

It implements the following:

Queue
ConcurrentLinkedQueue (class)

This makes it a powerful choice for multi-producer and multi-consumer environments.

---

Why Is ConcurrentLinkedQueue So Fast? (Internal Working)

ConcurrentLinkedQueue internally uses:

1. Linked Nodes

Each element is wrapped inside a linked node (like LinkedList).

2. CAS (Compare-And-Swap) Atomic Updates

Instead of locks, it uses CAS to:

• Add elements at the tail
• Remove elements from the head

This means:

• No locking
• No waiting
• No thread blocking
• Extremely low latency
• Multiple threads can operate simultaneously

Operations like offer() and poll() run in O(1) average time.

---

Features of ConcurrentLinkedQueue

1. Thread-Safe (Without Locks)

It achieves thread safety using atomic operations, not synchronized or ReentrantLocks.

2. FIFO Ordering

Elements are processed in the order they were inserted.

3. Unbounded Queue

It expands automatically depending on system memory.

4. High-Performance

Designed for heavily concurrent environments with minimal contention.

5. Weakly Consistent Iterators

Iteration:

• Does not block other operations
• Does not throw ConcurrentModificationException
• May not reflect real-time updates (acceptable in concurrent algorithms)

6. Non-Blocking Behavior

Methods like offer(), poll(), and peek() never block.

---

Common Methods of ConcurrentLinkedQueue

Method	Description
offer(e)	Adds element at the tail (always succeeds)
add(e)	Same as offer(), but may throw exception if fails
poll()	Removes and returns head, or null if empty
peek()	Returns head without removing (or null)
isEmpty()	Checks if queue is empty
size()	Returns count (but expensive & approximate)
iterator()	Returns weakly consistent iterator

---

Basic Example of ConcurrentLinkedQueue

import java.util.concurrent.ConcurrentLinkedQueue;

public class Main {
    public static void main(String[] args) {

        ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

        queue.offer("A");
        queue.offer("B");
        queue.offer("C");

        System.out.println("Queue: " + queue);

        System.out.println("Poll: " + queue.poll());
        System.out.println("Poll: " + queue.poll());

        System.out.println("After Poll: " + queue);

        System.out.println("Peek: " + queue.peek());
    }
}

Output

Queue: [A, B, C]
Poll: A
Poll: B
After Poll: [C]
Peek: C

---

Multi-Threaded Example (Producers)

import java.util.concurrent.ConcurrentLinkedQueue;

public class Demo {
    public static void main(String[] args) {

        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

        Runnable producer = () -> {
            for (int i = 1; i <= 5; i++) {
                queue.offer(i);
            }
        };

        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(producer);

        t1.start();
        t2.start();
    }
}

• No locks
• No synchronization required
• Threads never block

---

When Should You Use ConcurrentLinkedQueue?

Use it when you need:

• High-throughput message passing
• Low-latency communication between threads
• Non-blocking producer-consumer systems
• Multi-threaded queues without waiting
• Real-time data processing

Perfect for:

• Messaging/event queue
• Task scheduling systems
• Job dispatchers
• Real-time analytics
• Web server request pipelines
• Work-sharing systems

---

ConcurrentLinkedQueue vs LinkedBlockingQueue

Feature	ConcurrentLinkedQueue	LinkedBlockingQueue
Blocking	No	Yes
Capacity	Unbounded	Bounded/Unbounded
Locking	Lock-free (CAS)	Uses locks
Performance	Very fast	Slower under high concurrency
Use Case	Non-blocking apps	Producer-consumer with waiting

---

Advantages of ConcurrentLinkedQueue

• Extremely fast in concurrent environments
• No locking overhead
• Non-blocking, low-latency
• Unlimited size
• Safe multi-threading
• Iterators never fail

---

Disadvantages

• size() is slow and approximate
• No blocking methods (put(), take() not available)
• Not suitable when you need backpressure (bounded queue)

---

Points to Remember

ConcurrentLinkedQueue is ideal when:

• You need fast, scalable, non-blocking queue communication
• Multiple threads add/remove elements simultaneously
• You want to avoid locking overhead

It’s a top choice for modern concurrent systems, high-performance backends, and real-time applications.