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()); } }
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