LinkedBlockingQueue

LinkedBlockingQueue is an optionally bounded, thread-safe queue implemented in the Java standard library as part of java.util.concurrent. It implements the BlockingQueue interface and is designed for producer–consumer scenarios where multiple threads may insert and remove elements concurrently.

The queue is built on a linked node structure and uses two separate locks to permit higher throughput: one lock for producers (inserts) and one for consumers (removals). It maintains head and tail references to its linked nodes and uses condition variables to signal when the queue is not empty or not full. The capacity of the queue is defined at construction time. The no-argument constructor creates a queue with capacity Integer.MAX_VALUE, which is effectively unbounded for practical use; a constructor with a specified capacity enforces that bound and throws IllegalArgumentException if the capacity is not positive.

Common operations include: put(E e), which blocks if the queue is full until space becomes available; offer(E e), which inserts an element if there is space or returns false otherwise; take(), which blocks if the queue is empty until an element is available; poll(), which retrieves and removes the head or returns null if the queue is empty. RemainingCapacity() reports how many more elements can be added without blocking, and size() reports the current number of elements. The queue supports other standard BlockingQueue methods such as remove, peek, and contains through its AbstractQueue inheritance, with size and capacity operations designed to be efficient given the internal count maintained by the implementation.

LinkedBlockingQueue is commonly used as a work queue in thread pools and producer–consumer patterns. Its linked-node design allows a large, dynamically sized queue without preallocating a fixed storage array, at the cost of higher per-element allocation overhead compared to array-based queues.