In-Depth Comparison of ArrayBlockingQueue and LinkedBlockingQueue in Java

Java’s blocking queues are critical components for implementing producer-consumer patterns in concurrent programming.

1. ArrayBlockingQueue: Implementation Details

• Underlying Data Structure: Backed by an array Object[].
• Capacity: Fixed at initialization; bounded queue.
• Thread Safety
  • Uses a single ReentrantLock to control both read and write operations.
  • Two Condition variables: notEmpty (for consumers) and notFull (for producers).
• Blocking Behavior: Threads wait on the appropriate condition when the queue is empty/full.
• Performance: Simple implementation, but read/write operations are mutually exclusive.

As of the newest verion, ArrayBlockingQueue continues to use a single lock design. This simplifies the implementation and reduces overhead, but may become a performance bottleneck under high concurrency since producers and consumers cannot proceed in parallel.

2. LinkedBlockingQueue: Implementation Details

• Underlying Data Structure: Based on a singly-linked list.
• Capacity
  • Can be explicitly set;
  • Defaults to Integer.MAX_VALUE if not specified.
• Thread Safety
  • Uses two separate ReentrantLock instances
    • putLock for producers
    • takeLock for consumers
  • Two Condition objects: notEmpty and notFull, each tied to a different lock.
  • Queue size is tracked by an AtomicInteger count to ensure atomic updates.
• Concurrency Advantage: Read and write operations can proceed concurrently without contention.

3. Ensuring Safe Concurrent Access in LinkedBlockingQueue

The producer and consumer operations act on opposite ends of the queue:

• Producer
  • Appends a new node to tail.next and advances the tail pointer.
• Consumer
  • Removes head.next and advances the head pointer.

This separation ensures minimal contention. While the queue is empty:

• Both head and tail point to a dummy node with null data.
• This dummy node is reused until the first real element is inserted.

  public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null); // dummy node
  }
  

Dequeue Operation Example

The technique of self-linking (h.next = h) aids garbage collection by breaking unnecessary references.

private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

4. Blocking and Signaling (Condition Variables)

Both queues use Condition variables for signaling between producers and consumers.

5. Summary Comparison