Skip to content
Related Articles

Related Articles

Java Program to Implement DelayQueue API
  • Last Updated : 13 Jan, 2021

The DelayQueue class belongs to java.util.concurrent package. DelayQueue implements the BlockingQueue interface. DelayQueue is a specialized Priority Queue that orders elements supported their delay time. It means that only those elements can be taken from the queue whose time has expired. DelayQueue head contains the element that has expired within the least time. 

An unbounded blocking queue of Delayed elements, in which an element can only be taken when its delay has expired. The head of the queue is that Delayed element whose delay expired furthest in the past. If no delay has expired there is no head and the poll will return null. Expiration occurs when an element’s getDelay(TimeUnit.NANOSECONDS) method returns a value less than or equal to zero. Even though unexpired elements cannot be removed using take or poll, they are otherwise treated as normal elements. For example, the size method returns the count of both expired and unexpired elements. This queue does not permit null elements.

Procedure: 

  • Create a new DelayQueue that is initially empty. The DelayQueue class provides two constructors, one with no argument and one takes elements from another collection:

DelayQueue()

DelayQueue(Collection<? extends E> c)



  • Create a DelayQueue initially containing the elements of the given collection of Delayed instances.
  • Now, insert all the specified element into this delay queue using class “boolean add(E e)”.
  • Retrieve and Remove an element from the DelayQueue.

Implementation:

  • Step 1: Create a new DelayQueue that is initially empty.
  • Step 2: Creates a DelayQueue initially containing elements of a collection of delayed instances.
  • Step 3: Inserts the specified element into this delay queue.
  • Step 4: Removes all available elements from this queue and adds them to the given collection.
  • Step 5: Removes at most the given number of available elements from the queue and adds them to the given collection.
  • Step 6: Inserts the specified element at the tail of this queue if possible to do so immediately without exceeding the queue’s capacity.
  • Step 7: Inserts the specified element into the delay queue.
  • Step 8: Retrieve but do not remove the head of this queue or simply returns null if this queue is empty.
    • Step 8(a): Retrieves and removes the head of this queue or simply returns null if this queue is empty.
    • Step 8(b): Retrieves and removes the head of the queue waiting if necessary until an element with an expired delay is available on this queue.
  • Step 9: Insert the specified element into the delay queue.
  • Step 10: Removes a single instance of the specified element from this queue, if it is present.
  • Step 11:  Retrieves and removes the head of this queue, waiting if necessary until an element with an expired delay is available on this queue.

Example:

Java




// Java Program to implement DelayQueue API
  
// Importing classes from
// java.util package
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
  
// Class
public class DelayQueueImpl<E extends Delayed> {
    private DelayQueue<E> delayQueue;
  
    // Method 1
    public DelayQueueImpl()
    {
        // Step 1: Create a new DelayQueue
        // that is initially empty
        delayQueue = new DelayQueue<E>();
    }
  
    // Method 2 - Creating delayQueue
    // for containing elements
    public DelayQueueImpl(Collection<? extends E> c)
    {
  
        // Step 2: Creates a DelayQueue initially containing
        // elements of collection of Delayed instances
        delayQueue = new DelayQueue<>(c);
    }
  
    // Method 3
    // Step 3: Inserts the specified element
    // into this delay queue
    public boolean add(E e) { return delayQueue.add(e); }
  
    // Method 4
    public void clear()
    {
        // Automatically removes all of the elements
        // from this queue
        delayQueue.clear();
    }
  
    // Method 5
    public boolean contains(Object o)
    {
        // Returns true if this queue contains the specified
        // element else return false
        return delayQueue.contains(o);
    }
  
    // Method 6
    public int drainTo(Collection<? super E> c)
    {
        // Step 4: Removes all available elements from this
        // queue and adds them to the given collection.
        return delayQueue.drainTo(c);
    }
  
    // Method 7
    // Step 5: Removes at most the given number of available
    // elements from queue and adds them to the given
    // collection
    public int drainTo(Collection<? super E> c,
                       int maxElements)
    {
        return delayQueue.drainTo(c, maxElements);
    }
  
    // Method 8
    public Iterator<E> iterator()
    {
        // Returns an iterator over the elements
        // in this queue in proper sequence
        return delayQueue.iterator();
    }
  
    // Method 9
    // Step 6: Inserts the specified element at the tail of
    // this queue if possible to do so immediately without
    // exceeding the queue's capacity
  
    // Method 10
    public boolean offer(E e)
    {
        // Return true upon success and false
        // if this queuen is full else return false
        return delayQueue.offer(e);
    }
  
    // Step 7: Inserts the specified element into delay
    // queue
    public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return delayQueue.offer(e, timeout, unit);
    }
  
    // Method 11
    // Step 8: Retrieve but does not remove the head
    // of this queue
    public E peek()
    {
        // Or simply returns null if this queue is empty
        return delayQueue.peek();
    }
  
    // Step 8(a): Retrieves and removes the head of this
    // queue
    public E poll()
    {
  
        // Or simply returns null if this queue is empty.
        return delayQueue.poll();
    }
  
    // Step 8(b): Retrieves and removes the head of queue
    // waiting if necessary untilan element with an
    // expired delay is available on this queue
    public E poll(long timeout, TimeUnit unit)
        throws InterruptedException
    {
        return delayQueue.poll(timeout, unit);
    }
  
    // Method 12
    // Step 9: Insert the specified element into delay queue
    public void put(E e) throws InterruptedException
    {
        delayQueue.put(e);
    }
  
    // Method 13
    public int remainingCapacity()
    {
        // Remember : Always returns Integer.MAX_VALUE
        // because a DelayQueue is not capacity constrained
        return delayQueue.remainingCapacity();
    }
  
    // Step 10: Removes a single instance of the specified
    // element from this queue, if it is present
    public boolean remove(Object o)
    {
        return delayQueue.remove(o);
    }
    public int size() { 
      return delayQueue.size();
    }
    // Retrieves and removes the head of this queue, waiting
    // if necessary until an element with an expired delay
    // is available on this queue.
  
    public E take() throws InterruptedException
    {
        // Returns an array containing all of the elements
        // in
        // this queue, in proper sequence.
        return delayQueue.take();
    }
  
    public Object[] toArray()
    {
        // Returns an array containing all elements in queue
  
        return delayQueue.toArray();
    }
  
    // The runtime type of the returned array is
    // that of the specified array
    public <T> T[] toArray(T[] a)
    {
        return delayQueue.toArray(a);
    }
  
    // Class
    static class DelayObjects implements Delayed {
        // Member variable of class
        public long time;
  
        // Member function of class
        public DelayObjects()
        {
            getDelay(TimeUnit.MILLISECONDS);
        }
  
        // Overriding using compareTo() method
        @Override public int compareTo(Delayed o)
        {
            if (this.time < ((DelayObjects)o).time)
                return -1;
            else if (this.time > ((DelayObjects)o).time)
                return 1;
            return 0;
        }
  
        @Override public long getDelay(TimeUnit unit)
        {
            time = System.currentTimeMillis();
            return time;
        }
    }
  
    // Main driver method
    public static void main(String[] args)
        throws InterruptedException
    {
        // Creating object of class- DelayQueueImpl
        DelayQueueImpl<DelayObjects> arrayBlockingQueue
            = new DelayQueueImpl<DelayObjects>();
  
        // Adding custom inputs
        DelayObjects delayObject1 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject2 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject3 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject4 = new DelayObjects();
        Thread.sleep(100);
        DelayObjects delayObject5 = new DelayObjects();
  
        // Try blockk to check exceptions
        try {
            arrayBlockingQueue.put(delayObject1);
            arrayBlockingQueue.put(delayObject2);
            arrayBlockingQueue.put(delayObject3);
        }
  
        // Catach block to handle exceptions if occurs
        catch (InterruptedException e) {
            // Print the line number where exception occured
            e.printStackTrace();
        }
  
        // Adding objects to above queue
        arrayBlockingQueue.add(delayObject4);
        arrayBlockingQueue.add(delayObject5);
  
        // Display message
        System.out.print(
            "Delaytimes of the DelayQueue is           : ");
  
        // iterator to traverse over collection
        Iterator<DelayObjects> itr
            = arrayBlockingQueue.iterator();
  
        // Condition check using hasNext()
        while (itr.hasNext()) {
            // Print elements
            System.out.print(itr.next().time + "\t");
        }
  
        // New line
        System.out.println();
  
        // Using offr() method over objects
        arrayBlockingQueue.offer(new DelayObjects());
        arrayBlockingQueue.offer(new DelayObjects());
  
        // Print and Display messages to showcase
        // implementation of DelayQueue API
        System.out.println(
            "Element time of the DelayQueue by peeking :  "
            + arrayBlockingQueue.peek().time);
  
        System.out.println(
            "Remaining capcity                         : "
            + arrayBlockingQueue.remainingCapacity());
  
        System.out.println(
            "DelayObject1 removed ?                    : "
            + arrayBlockingQueue.remove(delayObject1));
  
        System.out.println(
            "DelayQueue contains DelayObject2 ?        : "
            + arrayBlockingQueue.contains(delayObject2));
  
        System.out.println(
            "hash DelayQueue contains DelayObject3 ?   : "
            + arrayBlockingQueue.contains(delayObject3));
  
        System.out.println(
            "Size of the ArrayBlocingQueue             : "
            + arrayBlockingQueue.size());
    }
}
Output
Delaytimes of the DelayQueue is           : 1609745787571    1609745787671    1609745787771    1609745787871    1609745787971    
Element time of the DelayQueue by peeking :  1609745787571
Remaining capcity                         : 2147483647
DelayObject1 removed ?                    : true
DelayQueue contains DelayObject2 ?        : true
hash DelayQueue contains DelayObject3 ?   : true
Size of the ArrayBlocingQueue             : 6

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 :