极客教程Java程序 实现DelayQueue API
DelayQueue类属于java.util.concurrent包。DelayQueue实现了BlockingQueue接口。DelayQueue是一个专门的优先级队列，它对元素的排序支持其延迟时间。这意味着只有那些时间已过的元素可以从队列中取出。DelayQueue头部包含了在最少时间内过期的元素。
一个由延迟元素组成的无界阻塞队列，其中一个元素只有在其延迟过期后才能被提取。队列的头是延迟过期最久的那个延迟元素。如果没有延迟过期，就没有头部，投票将返回null。当一个元素的getDelay(TimeUnit.NANOSECONDS)方法返回一个小于或等于0的值时，就发生了过期。尽管未过期的元素不能用take或poll来移除，但它们在其他方面被视为正常的元素。例如，size方法返回过期和未过期元素的数量。这个队列不允许空元素。
Procedure:
- 创建一个新的DelayQueue，最初是空的。DelayQueue类提供了两个构造函数，一个没有参数，一个从另一个集合获取元素。
DelayQueue()
DelayQueue(Collection<? extends E> c)
- 创建一个DelayQueue，最初包含给定的Delayed实例集合的元素。
- 现在，使用 “boolean add(E e) “类将所有指定的元素插入这个延迟队列。
- 从DelayQueue中检索和删除一个元素。
实现:
- 第1步：创建一个新的延迟队列，最初是空的。
- 第2步：创建一个最初包含延迟实例集合元素的延迟队列（DelayQueue）。
- 第3步：将指定的元素插入这个延迟队列中。
- 第4步：从这个队列中删除所有可用的元素，并将它们添加到给定的集合中。
- 第5步：从队列中最多删除给定数量的可用元素，并将其添加到给定的集合中。
- 第6步：如果可能的话，在不超过队列容量的情况下立即将指定元素插入该队列的尾部。
- 第7步：将指定的元素插入延迟队列中。
- 第8步：检索但不删除这个队列的头，如果这个队列是空的，则简单地返回空。
- 步骤8(a):检索并删除这个队列的头，如果这个队列是空的，则简单地返回空。
- 步骤8(b):检索并删除队列的头部，必要时等待，直到该队列上有一个延迟过期的元素可用。
- 第9步：将指定的元素插入延迟队列中。
- 第10步 :从这个队列中删除一个指定元素的单个实例，如果它存在的话。
- 第11步 :检索并删除该队列的头部，必要时等待，直到该队列上有一个延迟过期的元素。
示例:
// 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 offer() 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