import
java.util.Collection;
import
java.util.Iterator;
import
java.util.concurrent.DelayQueue;
import
java.util.concurrent.Delayed;
import
java.util.concurrent.TimeUnit;
public
class
DelayQueueImpl<E
extends
Delayed> {
private
DelayQueue<E> delayQueue;
public
DelayQueueImpl()
{
delayQueue =
new
DelayQueue<E>();
}
public
DelayQueueImpl(Collection<?
extends
E> c)
{
delayQueue =
new
DelayQueue<>(c);
}
public
boolean
add(E e) {
return
delayQueue.add(e); }
public
void
clear()
{
delayQueue.clear();
}
public
boolean
contains(Object o)
{
return
delayQueue.contains(o);
}
public
int
drainTo(Collection<?
super
E> c)
{
return
delayQueue.drainTo(c);
}
public
int
drainTo(Collection<?
super
E> c,
int
maxElements)
{
return
delayQueue.drainTo(c, maxElements);
}
public
Iterator<E> iterator()
{
return
delayQueue.iterator();
}
public
boolean
offer(E e)
{
return
delayQueue.offer(e);
}
public
boolean
offer(E e,
long
timeout, TimeUnit unit)
throws
InterruptedException
{
return
delayQueue.offer(e, timeout, unit);
}
public
E peek()
{
return
delayQueue.peek();
}
public
E poll()
{
return
delayQueue.poll();
}
public
E poll(
long
timeout, TimeUnit unit)
throws
InterruptedException
{
return
delayQueue.poll(timeout, unit);
}
public
void
put(E e)
throws
InterruptedException
{
delayQueue.put(e);
}
public
int
remainingCapacity()
{
return
delayQueue.remainingCapacity();
}
public
boolean
remove(Object o)
{
return
delayQueue.remove(o);
}
public
int
size() {
return
delayQueue.size();
}
public
E take()
throws
InterruptedException
{
return
delayQueue.take();
}
public
Object[] toArray()
{
return
delayQueue.toArray();
}
public
<T> T[] toArray(T[] a)
{
return
delayQueue.toArray(a);
}
static
class
DelayObjects
implements
Delayed {
public
long
time;
public
DelayObjects()
{
getDelay(TimeUnit.MILLISECONDS);
}
@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;
}
}
public
static
void
main(String[] args)
throws
InterruptedException
{
DelayQueueImpl<DelayObjects> arrayBlockingQueue
=
new
DelayQueueImpl<DelayObjects>();
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
{
arrayBlockingQueue.put(delayObject1);
arrayBlockingQueue.put(delayObject2);
arrayBlockingQueue.put(delayObject3);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
arrayBlockingQueue.add(delayObject4);
arrayBlockingQueue.add(delayObject5);
System.out.print(
"Delaytimes of the DelayQueue is : "
);
Iterator<DelayObjects> itr
= arrayBlockingQueue.iterator();
while
(itr.hasNext()) {
System.out.print(itr.next().time +
"\t"
);
}
System.out.println();
arrayBlockingQueue.offer(
new
DelayObjects());
arrayBlockingQueue.offer(
new
DelayObjects());
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());
}
}