Programa Java para implementar la API DelayQueue

La clase DelayQueue pertenece al paquete java.util.concurrent. DelayQueue implementa la interfaz BlockingQueue . DelayQueue es una cola de prioridad especializada que ordena elementos compatibles con 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 caducado en el menor tiempo. 

Una cola de bloqueo ilimitada de elementos retrasados, en la que un elemento solo se puede tomar cuando su retraso ha expirado. El encabezado de la cola es el elemento Retrasado cuyo retraso expiró más lejos en el pasado. Si no ha expirado ningún retraso, no hay cabeza y la encuesta devolverá un valor nulo. La caducidad se produce cuando el método getDelay(TimeUnit.NANOSECONDS) de un elemento devuelve un valor menor o igual a cero. Aunque los elementos que no han caducado no se pueden eliminar mediante Take o Poll, se tratan como elementos normales. Por ejemplo, el método de tamaño devuelve el recuento de elementos caducados y no caducados. Esta cola no permite elementos nulos.

Procedimiento: 

  • Cree una nueva DelayQueue que inicialmente esté vacía. La clase DelayQueue proporciona dos constructores, uno sin argumentos y otro que toma elementos de otra colección:

cola de retraso()

DelayQueue(Colección<? extiende E> c)

  • Cree un DelayQueue que inicialmente contenga los elementos de la colección dada de instancias retrasadas.
  • Ahora, inserte todo el elemento especificado en esta cola de retraso usando la clase «boolean add (E e)».
  • Recuperar y eliminar un elemento de DelayQueue.

Implementación:

  • Paso 1 : Cree una nueva DelayQueue que inicialmente esté vacía.
  • Paso 2 : crea un DelayQueue que inicialmente contiene elementos de una colección de instancias retrasadas.
  • Paso 3 : inserta el elemento especificado en esta cola de retraso.
  • Paso 4 : elimina todos los elementos disponibles de esta cola y los agrega a la colección dada.
  • Paso 5 : elimina como máximo el número dado de elementos disponibles de la cola y los agrega a la colección dada.
  • Paso 6 : inserta el elemento especificado al final de esta cola, si es posible hacerlo inmediatamente sin exceder la capacidad de la cola.
  • Paso 7 : Inserta el elemento especificado en la cola de retraso.
  • Paso 8 : Recupere pero no elimine el encabezado de esta cola o simplemente devuelva un valor nulo si esta cola está vacía.
    • Paso 8(a): recupera y elimina el encabezado de esta cola o simplemente devuelve un valor nulo si esta cola está vacía.
    • Paso 8(b): recupera y elimina el encabezado de la cola que espera, si es necesario, hasta que un elemento con un retraso vencido esté disponible en esta cola.
  • Paso 9 : inserte el elemento especificado en la cola de retraso.
  • Paso 10 : elimina una sola instancia del elemento especificado de esta cola, si está presente.
  • Paso 11 : recupera y elimina el encabezado de esta cola, esperando si es necesario hasta que un elemento con un retraso vencido esté disponible en esta cola.

Ejemplo:

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 queue 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 block to check exceptions
        try {
            arrayBlockingQueue.put(delayObject1);
            arrayBlockingQueue.put(delayObject2);
            arrayBlockingQueue.put(delayObject3);
        }
 
        // Catch block to handle exceptions if occurs
        catch (InterruptedException e) {
            // Print the line number where exception occurred
            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 capacity                         : "
            + 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());
    }
}
Producción

Delaytimes of the DelayQueue is           : 1626870778483    1626870778583    1626870778683    1626870778786    1626870778886    
Element time of the DelayQueue by peeking :  1626870778483
Remaining capacity                         : 2147483647
DelayObject1 removed ?                    : true
DelayQueue contains DelayObject2 ?        : true
hash DelayQueue contains DelayObject3 ?   : true
Size of the ArrayBlocingQueue             : 6

Publicación traducida automáticamente

Artículo escrito por mayanktyagi1709 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *