| Methods Summary |
|---|
| public boolean | add(E o)Adds the specified element to this queue.
return offer(o);
|
| public void | clear()Atomically removes all of the elements from this delay queue.
The queue will be empty after this call returns.
final ReentrantLock lock = this.lock;
lock.lock();
try {
q.clear();
} finally {
lock.unlock();
}
|
| public int | drainTo(java.util.Collection c)
if (c == null)
throw new NullPointerException();
if (c == this)
throw new IllegalArgumentException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
int n = 0;
for (;;) {
E first = q.peek();
if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
break;
c.add(q.poll());
++n;
}
if (n > 0)
available.signalAll();
return n;
} finally {
lock.unlock();
}
|
| public int | drainTo(java.util.Collection c, int maxElements)
if (c == null)
throw new NullPointerException();
if (c == this)
throw new IllegalArgumentException();
if (maxElements <= 0)
return 0;
final ReentrantLock lock = this.lock;
lock.lock();
try {
int n = 0;
while (n < maxElements) {
E first = q.peek();
if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
break;
c.add(q.poll());
++n;
}
if (n > 0)
available.signalAll();
return n;
} finally {
lock.unlock();
}
|
| public java.util.Iterator | iterator()Returns an iterator over the elements in this queue. The iterator
does not return the elements in any particular order. The
returned iterator is a thread-safe "fast-fail" iterator that will
throw {@link java.util.ConcurrentModificationException}
upon detected interference.
final ReentrantLock lock = this.lock;
lock.lock();
try {
return new Itr(q.iterator());
} finally {
lock.unlock();
}
|
| public boolean | offer(E o)Inserts the specified element into this delay queue.
final ReentrantLock lock = this.lock;
lock.lock();
try {
E first = q.peek();
q.offer(o);
if (first == null || o.compareTo(first) < 0)
available.signalAll();
return true;
} finally {
lock.unlock();
}
|
| public boolean | offer(E o, long timeout, java.util.concurrent.TimeUnit unit)Inserts the specified element into this delay queue. As the queue is
unbounded this method will never block.
return offer(o);
|
| public E | peek()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.peek();
} finally {
lock.unlock();
}
|
| public E | poll(long time, java.util.concurrent.TimeUnit unit)
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
long nanos = unit.toNanos(time);
try {
for (;;) {
E first = q.peek();
if (first == null) {
if (nanos <= 0)
return null;
else
nanos = available.awaitNanos(nanos);
} else {
long delay = first.getDelay(TimeUnit.NANOSECONDS);
if (delay > 0) {
if (delay > nanos)
delay = nanos;
long timeLeft = available.awaitNanos(delay);
nanos -= delay - timeLeft;
} else {
E x = q.poll();
assert x != null;
if (q.size() != 0)
available.signalAll();
return x;
}
}
}
} finally {
lock.unlock();
}
|
| public E | poll()
final ReentrantLock lock = this.lock;
lock.lock();
try {
E first = q.peek();
if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
return null;
else {
E x = q.poll();
assert x != null;
if (q.size() != 0)
available.signalAll();
return x;
}
} finally {
lock.unlock();
}
|
| public void | put(E o)Adds the specified element to this delay queue. As the queue is
unbounded this method will never block.
offer(o);
|
| public int | remainingCapacity()Always returns Integer.MAX_VALUE because
a DelayQueue is not capacity constrained.
return Integer.MAX_VALUE;
|
| public boolean | remove(java.lang.Object o)
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.remove(o);
} finally {
lock.unlock();
}
|
| public int | size()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.size();
} finally {
lock.unlock();
}
|
| public E | take()
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
E first = q.peek();
if (first == null) {
available.await();
} else {
long delay = first.getDelay(TimeUnit.NANOSECONDS);
if (delay > 0) {
long tl = available.awaitNanos(delay);
} else {
E x = q.poll();
assert x != null;
if (q.size() != 0)
available.signalAll(); // wake up other takers
return x;
}
}
}
} finally {
lock.unlock();
}
|
| public java.lang.Object[] | toArray()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.toArray();
} finally {
lock.unlock();
}
|
| public T[] | toArray(T[] array)
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.toArray(array);
} finally {
lock.unlock();
}
|
