Clase DelayQueue en Java con ejemplo

La clase DelayQueue es miembro de Java Collections Framework. Pertenece al paquete java.util.concurrent . DelayQueue implementa la interfaz BlockingQueue . DelayQueue es una cola de prioridad especializada que ordena elementos en función de su tiempo de retraso. Significa que solo se pueden tomar de la cola aquellos elementos cuyo tiempo haya expirado. 
El encabezado DelayQueue contiene el elemento que ha expirado en el menor tiempo. Si no ha expirado ningún retraso, entonces no hay cabeza y la encuesta devolverá un valor nulo. DelayQueue acepta solo aquellos elementos que pertenecen a una clase de tipo Delayed o implementan java.util.concurrent.Delayedinterfaz. El DelayQueue bloquea los elementos internamente hasta que expira un determinado retraso. DelayQueue implementa el método getDelay(TimeUnit.NANOSECONDS) para devolver el tiempo de retraso restante. La instancia de TimeUnit que se pasa al método getDelay() es una enumeración que indica en qué unidad de tiempo debe devolverse el retraso. La enumeración de TimeUnit puede tomar DÍAS, HORAS, MINUTOS, SEGUNDOS, MILISEGUNDOS, MICROSEGUNDOS, NANOSEGUNDOS. Esta cola no permite elementos nulos. Esta clase y su iterador implementan todos los métodos opcionales de las interfaces Collection e Iterator . No se garantiza que el iterador provisto en el método iterator() atraviese los elementos de DelayQueue en un orden particular. 

// Declaración de interfaz retrasada

interfaz pública Delayed extiende Comparable<Delayed>

{

/**

    * Devuelve el retraso restante asociado a este objeto, en el

    * unidad de tiempo dada.

    *

    * @param unidad la unidad de tiempo

    *

    * @return el retraso restante; valores cero o negativos indican

    * que el retraso ya ha transcurrido

    */

   long getDelay(unidad de unidad de tiempo);

}

La jerarquía de DelayQueue

Implementa las interfaces Iterable<E> , Collection<E> , BlockingQueue<E> , Queue<E> .

Declaración de clase:  

public class DelayQueue<E extiende Delayed> extiende AbstractQueue<E> implementa BlockingQueue<E>
 

Aquí, E es el tipo de elemento mantenido por esta colección.

Constructores de DelayQueue

Para construir un DelayQueue, debemos importarlo desde java.util.concurrent.DelayQueue .

1. DelayQueue() : este constructor se utiliza para construir una DelayQueue vacía.

DelayQueue<E> dq = new DelayQueue<E>();

2. DelayQueue(Collection<E> c) : este constructor se usa para construir una DelayQueue con los elementos de la colección de instancias retrasadas pasadas como parámetro.

DelayQueue<E> dq = new DelayQueue(Colección<E> c);

A continuación se muestra un programa de ejemplo para ilustrar DelayQueue en Java:
 

// Java Program Demonstrate DelayQueue
 
import java.util.concurrent.*;
import java.util.*;
 
// The DelayObject for DelayQueue
// It must implement Delayed and
// its getDelay() and compareTo() method
class DelayObject implements Delayed {
   
    private String name;
    private long time;
 
    // Constructor of DelayObject
    public DelayObject(String name, long delayTime)
    {
        this.name = name;
        this.time = System.currentTimeMillis()
                    + delayTime;
    }
 
    // Implementing getDelay() method of Delayed
    @Override
    public long getDelay(TimeUnit unit)
    {
        long diff = time - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }
 
    // Implementing compareTo() method of Delayed
    @Override
    public int compareTo(Delayed obj)
    {
        if (this.time < ((DelayObject)obj).time) {
            return -1;
        }
        if (this.time > ((DelayObject)obj).time) {
            return 1;
        }
        return 0;
    }
 
    // Implementing toString() method of Delayed
    @Override
    public String toString()
    {
        return "\n{"
            + "name=" + name
            + ", time=" + time
            + "}";
    }
}
 
// Driver Class
public class GFG {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of DelayQueue
        // using DelayQueue() constructor
        BlockingQueue<DelayObject> DQ
            = new DelayQueue<DelayObject>();
 
        // Add numbers to end of DelayQueue
        DQ.add(new DelayObject("A", 1));
        DQ.add(new DelayObject("B", 2));
        DQ.add(new DelayObject("C", 3));
        DQ.add(new DelayObject("D", 4));
 
        // print DelayQueue
        System.out.println("DelayQueue: "
                           + DQ);
 
        // create object of DelayQueue
        // using DelayQueue(Collection c)
        // constructor
        BlockingQueue<DelayObject> DQ2
            = new DelayQueue<DelayObject>(DQ);
 
        // print DelayQueue
        System.out.println("DelayQueue: "
                           + DQ2);
    }
}

DelayQueue: [
{name=A, time=1543472836003}, 
{name=B, time=1543472836004}, 
{name=C, time=1543472836005}, 
{name=D, time=1543472836006}]
DelayQueue: [
{name=A, time=1543472836003}, 
{name=B, time=1543472836004}, 
{name=C, time=1543472836005}, 
{name=D, time=1543472836006}]

A continuación se muestra un programa de muestra para ilustrar los métodos de DelayQueue en Java:

// Java Program Demonstrate DelayQueue methods
 
import java.util.concurrent.*;
import java.util.*;
 
// The DelayObject for DelayQueue
// It must implement Delayed and
// its getDelay() and compareTo() method
class DelayObject implements Delayed {
   
    private String name;
    private long time;
 
    // Constructor of DelayObject
    public DelayObject(String name, long delayTime)
    {
        this.name = name;
        this.time = System.currentTimeMillis()
                    + delayTime;
    }
 
    // Implementing getDelay() method of Delayed
    @Override
    public long getDelay(TimeUnit unit)
    {
        long diff = time - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }
 
    // Implementing compareTo() method of Delayed
    @Override
    public int compareTo(Delayed obj)
    {
        if (this.time < ((DelayObject)obj).time) {
            return -1;
        }
        if (this.time > ((DelayObject)obj).time) {
            return 1;
        }
        return 0;
    }
 
    // Implementing toString()
      // method of Delayed
    @Override
    public String toString()
    {
        return "\n{"
            + "name=" + name
            + ", time=" + time
            + "}";
    }
}
 
// Driver Class
public class GFG {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of DelayQueue
        // using DelayQueue() constructor
        BlockingQueue<DelayObject> DQ
            = new DelayQueue<DelayObject>();
 
        // Add numbers to end of DelayQueue
        // using add() method
        DQ.add(new DelayObject("A", 1));
        DQ.add(new DelayObject("B", 2));
        DQ.add(new DelayObject("C", 3));
        DQ.add(new DelayObject("D", 4));
 
        // print queue
        System.out.println("DelayQueue: "
                           + DQ);
 
        // print the head using peek() method
        System.out.println("Head of DelayQueue: "
                           + DQ.peek());
 
        // print the size using size() method
        System.out.println("Size of DelayQueue: "
                           + DQ.size());
 
        // remove the head using poll() method
        System.out.println("Head of DelayQueue: "
                           + DQ.poll());
 
        // print the size using size() method
        System.out.println("Size of DelayQueue: "
                           + DQ.size());
 
        // clear the DelayQueue using clear() method
        DQ.clear();
        System.out.println("Size of DelayQueue"
                           + " after clear: "
                           + DQ.size());
    }
}

DelayQueue: [
{name=A, time=1543472845012}, 
{name=B, time=1543472845013}, 
{name=C, time=1543472845014}, 
{name=D, time=1543472845015}]

Head of DelayQueue: 
{name=A, time=1543472845012}

Size of DelayQueue: 4

Head of DelayQueue: 
{name=A, time=1543472845012}

Size of DelayQueue: 3

Size of DelayQueue after clear: 0

Operaciones básicas

1. Agregar elementos

El método add(E e) de la clase DelayQueue en Java se usa para insertar el elemento dado en la cola de retraso y devuelve verdadero si el elemento se ha insertado correctamente. 

// Java program to illustrate the adding
// elements to the DelayQueue
 
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
 
public class AddingElementsExample {
    public static void main(String args[])
    {
        // Create a DelayQueue instance
        DelayQueue<Delayed> queue
            = new DelayQueue<Delayed>();
 
        // Create an instance of Delayed
        Delayed obj = new Delayed() {
            public long getDelay(TimeUnit unit)
            {
                return 24; // some value is returned
            }
 
            public int compareTo(Delayed o)
            {
                if (o.getDelay(TimeUnit.DAYS)
                    > this.getDelay(TimeUnit.DAYS))
                    return 1;
                else if (o.getDelay(TimeUnit.DAYS)
                         == this.getDelay(TimeUnit.DAYS))
                    return 0;
                return -1;
            }
        };
 
        // Use the add() method to add obj to
        // the empty DelayQueue instance
        queue.add(obj);
 
        // printing size of the queue to the console
        System.out.println("Size of the queue : "
                           + queue.size());
    }
}

Size of the queue : 1

2. Eliminación de elementos

El método remove() de la clase DelayQueue en Java se usa para eliminar una sola instancia del objeto dado, digamos obj, de esta DelayQueue si está presente. Devuelve verdadero si el elemento dado se elimina con éxito; de lo contrario, devuelve falso.  

// Java Program to illustrate the removing
// elements of DelayQueue class
 
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;
 
public class RemovingElementsExample {
    public static void main(String args[])
    {
        // Create a DelayQueue instance
        DelayQueue<Delayed> queue = new DelayQueue<Delayed>();
 
        // Create an object of type Delayed
        Delayed ob = new Delayed() {
            public long getDelay(TimeUnit unit)
            {
                return 24; // some value is returned
            }
 
            public int compareTo(Delayed o)
            {
                if (o.getDelay(TimeUnit.DAYS)
                    > this.getDelay(TimeUnit.DAYS))
                    return 1;
                else if (o.getDelay(TimeUnit.DAYS)
                         == this.getDelay(TimeUnit.DAYS))
                    return 0;
                return -1;
            }
        };
 
        // Add the object to DelayQueue
        queue.add(ob);
 
        // Print initial size of Queue
        System.out.println("Initial Size : " + queue.size());
 
        // Remove the object ob from
        // this DelayQueue
        queue.remove(ob);
 
        // Print the final size of the DelayQueue
        System.out.println("Size after removing : " + queue.size());
    }
}

Initial Size : 1
Size after removing : 0

3. Accediendo a Elementos

El método peek() de DelayQueue se usa para recuperar el encabezado de DelayQueue, pero no lo elimina, como en el caso del método poll() donde el encabezado se elimina de DelayQueue.

// Java Program Demonstrate accessing
// elements of DelayQueue
 
import java.util.concurrent.*;
import java.util.*;
 
// The DelayObject for DelayQueue
// It must implement Delayed and
// its getDelay() and compareTo() method
class DelayObject implements Delayed {
 
    private String name;
    private long time;
 
    // Constructor of DelayObject
    public DelayObject(String name, long delayTime)
    {
        this.name = name;
        this.time = System.currentTimeMillis() + delayTime;
    }
 
    // Implementing getDelay() method of Delayed
    @Override public long getDelay(TimeUnit unit)
    {
        long diff = time - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }
 
    // Implementing compareTo() method of Delayed
    @Override public int compareTo(Delayed obj)
    {
        if (this.time < ((DelayObject)obj).time) {
            return -1;
        }
        if (this.time > ((DelayObject)obj).time) {
            return 1;
        }
        return 0;
    }
 
    // Implementing toString() method of Delayed
    @Override public String toString()
    {
        return "\n{"
            + " " + name + ", time=" + time + "}";
    }
}
 
// Driver Class
public class AccessingElementsExample {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of DelayQueue
        // using DelayQueue() constructor
        BlockingQueue<DelayObject> DQ = new DelayQueue<DelayObject>();
 
        // Add numbers to end of DelayQueue
        // using add() method
        DQ.add(new DelayObject("A", 1));
        DQ.add(new DelayObject("B", 2));
       
        // Print delayqueue
        System.out.println("Original DelayQueue: " + DQ + "\n");
       
        // removing all elements
        DQ.clear();
       
        // peek() method for returning head of the
        // DelayQueue
        System.out.println("Head of the DelayQueue: " + DQ.peek());
    }
}

Original DelayQueue: [
{ A, time=1600770273132}, 
{ B, time=1600770273134}]

Head of the DelayQueue: null

4. Atravesando

El método iterator () de DelayQueue se usa para devolver un iterador sobre todos los elementos en DelayQueue.

// Java Program Demonstrate iterating
// over DelayQueue
 
import java.util.concurrent.*;
import java.util.*;
 
// The DelayObject for DelayQueue
// It must implement Delayed and
// its getDelay() and compareTo() method
class DelayObject implements Delayed {
 
    private String name;
    private long time;
 
    // Constructor of DelayObject
    public DelayObject(String name, long delayTime)
    {
        this.name = name;
        this.time = System.currentTimeMillis() + delayTime;
    }
 
    // Implementing getDelay() method of Delayed
    @Override public long getDelay(TimeUnit unit)
    {
        long diff = time - System.currentTimeMillis();
        return unit.convert(diff, TimeUnit.MILLISECONDS);
    }
 
    // Implementing compareTo() method of Delayed
    @Override public int compareTo(Delayed obj)
    {
        if (this.time < ((DelayObject)obj).time) {
            return -1;
        }
        if (this.time > ((DelayObject)obj).time) {
            return 1;
        }
        return 0;
    }
 
    // Implementing toString() method of Delayed
    @Override public String toString()
    {
        return "\n{"
            + " " + name + ", time=" + time + "}";
    }
}
 
// Driver Class
public class IteratingExample {
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // create object of DelayQueue
        // using DelayQueue() constructor
        BlockingQueue<DelayObject> DQ = new DelayQueue<DelayObject>();
 
        // Add numbers to end of DelayQueue
        // using add() method
        DQ.add(new DelayObject("A", 1));
        DQ.add(new DelayObject("B", 2));
        DQ.add(new DelayObject("C", 3));
        DQ.add(new DelayObject("D", 4));
 
        // Creating an iterator
        Iterator val = DQ.iterator();
 
        // print the value after iterating DelayQueue
        System.out.println("The iterator values are: ");
        while (val.hasNext()) {
            System.out.println(val.next());
        }
    }
}

The iterator values are: 

{ A, time=1600770415898}

{ B, time=1600770415900}

{ C, time=1600770415901}

{ D, time=1600770415902}

Métodos de DelayQueue

Métodos declarados en la clase java.util.AbstractQueue

Métodos declarados en la clase java.util.AbstractCollection

Métodos declarados en la interfaz java.util.concurrent.BlockingQueue

Métodos declarados en la interfaz java.util.Collection

Métodos declarados en la interfaz java.lang.Iterable

Métodos declarados en la interfaz java.util.Queue

Referencia: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/DelayQueue.html