What are BlockingQueue implementations?

• ArrayBlockingQueue – fixed-size array, ONE ReentrantLock for both put and take, optional fairness (FIFO for waiting threads).
• LinkedBlockingQueue – linked nodes, TWO separate locks (putLock + takeLock). Put and take can run concurrently, giving higher throughput. Can be bounded or unbounded.
• PriorityBlockingQueue – unbounded min-heap. Elements ordered by Comparator or Comparable. poll() returns the smallest (highest priority), NOT FIFO. Only blocks on take() when empty.
• SynchronousQueue – ZERO internal capacity. put() blocks until a consumer calls take(). take() blocks until a producer calls put(). Direct handoff with no buffering. Used by newCachedThreadPool().
• DelayQueue – elements implement Delayed interface. take() blocks until the element's delay expires. Used for scheduled execution, retry with backoff, cache expiration.

What are the five BlockingQueue implementations?

Java provides five standard BlockingQueue implementations, each designed for a specific concurrency use case.

package com.bank.concurrency;

import java.util.concurrent.*;

public class BlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        // ArrayBlockingQueue: fixed capacity, one lock, optional fairness
        BlockingQueue<String> arrayBQ = new ArrayBlockingQueue<>(100, true);

        // LinkedBlockingQueue: two locks, higher throughput
        BlockingQueue<String> linkedBQ = new LinkedBlockingQueue<>(1000);

        // PriorityBlockingQueue: heap-ordered, unbounded
        BlockingQueue<String> priorityBQ = new PriorityBlockingQueue<>();

        // SynchronousQueue: zero capacity, direct handoff
        BlockingQueue<String> syncQ = new SynchronousQueue<>();

        // DelayQueue: time-based release
        DelayQueue<DelayedTask> delayQ = new DelayQueue<>();
    }
}

How are they different?

| Queue | Capacity | Locks | Order | Blocks on | Use case |
|---|---|---|---|---|---|
| ArrayBlockingQueue | Fixed | 1 | FIFO | put + take | Bounded buffer, fairness required |
| LinkedBlockingQueue | Bounded/unbounded | 2 | FIFO | put + take | Producer-consumer, ThreadPool default |
| PriorityBlockingQueue | Unbounded | 1 | Priority | take only | Priority processing |
| SynchronousQueue | 0 | N/A | Handoff | put + take | Direct handoff, CachedPool |
| DelayQueue | Unbounded | 1 | Delay | take only | Scheduled tasks, retry |

Why does LinkedBlockingQueue have higher throughput?

LinkedBlockingQueue uses two separate locks: a putLock for producers and a takeLock for consumers. This means put() and take() can run concurrently on different threads without contending for the same lock. ArrayBlockingQueue uses a single ReentrantLock for both operations, so producers and consumers serialize on the same lock.

// LinkedBlockingQueue internal structure (simplified):
// putLock -> protects the tail of the linked list
// takeLock -> protects the head of the linked list
// Producer adds at tail (putLock), Consumer removes from head (takeLock)
// Both can proceed simultaneously!

// ArrayBlockingQueue internal structure (simplified):
// Single lock -> protects the entire array
// Producer and consumer must take turns

When would you use each one in a banking system?

At National Bank of India, different queues serve different purposes.

package com.bank.queues;

import java.math.BigDecimal;
import java.util.concurrent.*;

public class BankingQueueExamples {

    // Settlement queue: bounded, high-throughput producer-consumer
    private final BlockingQueue<Settlement> settlementQueue =
        new LinkedBlockingQueue<>(10_000);

    // VIP trade queue: highest-value trades processed first
    private final BlockingQueue<Trade> vipQueue =
        new PriorityBlockingQueue<>(100,
            (a, b) -> b.getValue().compareTo(a.getValue())); // highest value first

    // Retry queue: failed payments retried after a 30-second delay
    private final DelayQueue<RetryablePayment> retryQueue = new DelayQueue<>();
}

How does SynchronousQueue work as direct handoff?

SynchronousQueue has zero internal capacity. put() blocks until a consumer calls take(), and take() blocks until a producer calls put(). This provides direct handoff with no buffering. It is used internally by Executors.newCachedThreadPool() because the pool needs a new thread for every task that arrives when no idle thread is available.

How does DelayQueue enforce time-based release?

Elements must implement the Delayed interface. take() blocks until the element's delay has expired. Elements are ordered by expiry time.

package com.bank.retry;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class RetryablePayment implements Delayed {
    private final String paymentId;
    private final long retryAt;  // epoch millis

    public RetryablePayment(String paymentId, long delayMs) {
        this.paymentId = paymentId;
        this.retryAt = System.currentTimeMillis() + delayMs;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(retryAt - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        return Long.compare(this.retryAt, ((RetryablePayment) other).retryAt);
    }
}

What are common mistakes?

Using an unbounded LinkedBlockingQueue (no capacity specified) with a ThreadPoolExecutor hides pool saturation. The queue grows without limit, consuming memory, and tasks wait indefinitely instead of being rejected. Always specify a capacity.

// WRONG: unbounded queue hides saturation
new LinkedBlockingQueue<>()  // grows to Integer.MAX_VALUE

// CORRECT: bounded queue with rejection policy
new LinkedBlockingQueue<>(1000)

What are common interview follow-up questions?

• Is PriorityBlockingQueue thread-safe? Yes, but its iterator does NOT guarantee any particular order. Only poll() and take() guarantee priority order.
• Can SynchronousQueue hold even one element? No. It has zero capacity. Every put() must rendezvous with a take().
• What queue does ThreadPoolExecutor use by default? It depends on how you create it. Executors.newFixedThreadPool uses unbounded LinkedBlockingQueue. Executors.newCachedThreadPool uses SynchronousQueue.