Skip to content
Related Articles

Related Articles

Improve Article

Difference Between ArrayBlockingQueue and LinkedBlockingQueue

  • Last Updated : 19 Oct, 2020
Geek Week

ArrayBlockingQueue and LinkedBlockingQueue in Java Collection are the common implementations of the BlockingQueue interface.

ArrayBlockingQueue: ArrayBlockingQueue is a class in Java that implements the BlockingQueue interface. ArrayBlockingQueue class and its iterator implement all the optional methods of the Collection and Iterator interfaces. ArrayBlockingQueue is a bounded BlockingQueue backed by an array. Here, bounded means the size of the Queue is finite and fixed. Once created, we cannot grow or shrink the size of the Queue. If we try to insert an element into a full Queue then it will result in the operation blocking. Similarly, if we try to take an element from an empty Queue, then also the operation will be blocked. ArrayBlockingQueue stores the elements in the Queue internally in the FIFO (first-in-first-out) order. The element at the head or front of the Queue is the oldest element of all the elements present in this queue. The element at the tail of this queue is the newest element of all the elements of this queue. The new elements are always inserted at the end or tail of the queue and the retrieval operations obtain elements at the head of the queue.

LinkedBlockingQueue: LinkedBlockingQueue is a class in Java that implements the BlockingQueue interface. LinkedBlockingQueue is an optionally-bounded BlockingQueue backed by linked nodes. Here, optionally-bounded means the capacity given to LinkedBlockingQueue is bounded, otherwise, it will be unbounded. The capacity can be given as a parameter to the constructor of LinkedBlockingQueue. The capacity, if unspecified, is equal to Integer.MAX_VALUE. LinkedBlockingQueue class and its iterator implement all the optional methods of the Collection and Iterator interfaces. LinkedBlockingQueue stores the elements in the Queue internally in the FIFO (first-in-first-out) order. The element at the head or front of the Queue is the oldest element of all the elements present in this queue. The element at the tail of this queue is the newest element of all the elements of this queue. The new elements are always inserted at the end or tail of the queue and the retrieval operations obtain elements at the head of the queue. Linked queues typically have higher throughput than array-based queues but less predictable performance in most concurrent applications.

LinkedBlockingQueue Demo

Java




// Java program to demonstrate LinkedBlockingQueue
  
import java.util.concurrent.LinkedBlockingQueue;
  
public class LinkedBlockingQueueDemo {
  
    public static void main(String[] args)
    {
        // define capacity of LinkedBlockingQueue
        int capacity = 15;
  
        // create object of LinkedBlockingQueue
        LinkedBlockingQueue<Integer> lbq
            = new LinkedBlockingQueue<Integer>(capacity);
  
        // add numbers
        lbq.add(1);
        lbq.add(2);
        lbq.add(3);
  
        // print queue
        System.out.println("LinkedBlockingQueue:" + lbq);
    }
}
Output



LinkedBlockingQueue:[1, 2, 3]

ArrayBlockingQueue Demo

Java




// Java program to demonstrate
// ArrayBlockingQueue
  
import java.util.concurrent.ArrayBlockingQueue;
  
public class ArrayBlockingQueueDemo {
  
    public static void main(String[] args)
    {
        // define capacity of ArrayBlockingQueue
        int capacity = 15;
  
        // create object of ArrayBlockingQueue
        // using ArrayBlockingQueue(int initialCapacity)
        // constructor
        ArrayBlockingQueue<Integer> abq
            = new ArrayBlockingQueue<Integer>(capacity);
  
        // add numbers
        abq.add(1);
        abq.add(2);
        abq.add(3);
  
        // print queue
        System.out.println("ArrayBlockingQueue:" + abq);
    }
}
Output
ArrayBlockingQueue:[1, 2, 3]

Difference between ArrayBlockingQueue and LinkedBlockingQueue:

       ArrayBlockingQueue

                                  LinkedBlockingQueue

It stores the elements internally in an array.It stores the elements internally in linked nodes.
ArrayBlockingQueue is bounded which means the size will never change after its creation.LinkedBlockingQueue is optionally bounded which means it can optionally have an upper bound if desired. If no upper bound is specified, Integer.MAX_VALUE is used as the upper bound.
It has lower throughput than linked nodes queues.It has a higher throughput than array-based queues.
It uses the single-lock double condition algorithm. It means that producer and consumer share a single lock.It uses two lock queue algorithms and it has two lock conditions putLock and takeLock for inserting and removing elements respectively from the Queue.
ArrayBlockingQueue always holds an object arrayLinkedBlockingQueue is a linked node with an object with three object fields.

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :