ArrayBlockingQueue vs. LinkedBlockingQueue

Last updated: December 7, 2023

Written by: baeldung

Reviewed by: Eric Martin

Java Queue

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

Java BlockingQueue interface represents a thread-safe queue. It blocks a thread trying to put elements in the queue if the queue is full. It also blocks a thread trying to take elements from the queue if the queue is empty.

There are various implementations of BlockingQueue like ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue.

In this tutorial, we’ll look at the differences between ArrayBlockingQueue and LinkedBlockingQueue.

2. ArrayBlockingQueue

An ArrayBlockingqueue is a bounded queue. It internally uses an array. We can mention the size of the array when creating its instance.

The below code snippet shows how we can create an object of ArrayBlockingQueue. We have mentioned the size of the internal array as 10:

int INIT_CAPACITY = 10;

BlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(INIT_CAPACITY, true);

If we insert elements in the queue beyond the defined capacity and the queue is full, then the add operation throws IllegalStateException. Also, if we set the initial size to less than 1, we’ll get IllegalArgumentException.

Here the second parameter represents the fairness policy. We can optionally set the fairness policy to preserve the order of blocked producer and consumer threads. It allows queue access for blocked threads in FIFO order. Thus, the thread that went into the waiting state first will first get the chance to access the queue. This helps to avoid thread starvation.

3. LinkedBlockingQueue

A LinkedBlockingQueue is an optionally bounded implementation of BlockingQueue. It’s backed by linked nodes.

We can also specify the capacity while creating its instance. If not specified, then Integer.MAX_VALUE is set as capacity.

Linked nodes are dynamically created when elements are inserted.

Let’s see how we can create a LinkedBlockingQueue:

BlockingQueue<String> linkedBlockingQueue = new LinkedBlockingQueue<>();

4. ArrayBlockingQueue vs. LinkedBlockingQueue

Even though both ArrayBlockingQueue and LinkedBlockingQueue are implementations of BlockingQueue and store elements in FIFO order, there are certain differences between them. Now we’ll look at those differences:

Feature	ArrayBlockingQueue	LinkedBlockingQueue
Implementation	It’s backed by an array	It uses linked nodes
Queue Size	It’s a bounded queue. Therefore, it’s mandatory to specify the initial capacity while creating it.	It’s not mandatory to mention size.
Fairness Policy	We can set a fairness policy in it	There’s no option to set a fairness policy in this
Number of Locks	It uses one ReentrantLock. The same lock is used for both put and take operations.	It uses separate ReentrantLock for read and write operations. This prevents contention between producer and consumer threads.
Memory space	Since it’s mandatory to mention initial capacity in it, we can end up allocating more space than required.	It usually doesn’t pre-allocate nodes. Therefore, its memory footprint matches its size

5. Conclusion

In this article, we learned about the differences between ArrayBlockingQueue and LinkedBlockingQueue. The ArrayBlockingQueue is backed up by an array, and the LinkedBlockingQueue by linked nodes. We also touched upon the additional feature of the fairness policy that exists in ArrayBlockingQueue and the locking mechanism and memory footprint of both queues.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.