| Methods Summary |
|---|
| public boolean | add(E o)Adds the specified element to this queue.
return super.add(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 java.util.Comparator | comparator()Returns the comparator used to order this collection, or null
if this collection is sorted according to its elements natural ordering
(using Comparable).
return q.comparator();
|
| public boolean | contains(java.lang.Object o)
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.contains(o);
} 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;
E e;
while ( (e = q.poll()) != null) {
c.add(e);
++n;
}
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;
E e;
while (n < maxElements && (e = q.poll()) != null) {
c.add(e);
++n;
}
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 priority queue.
if (o == null) throw new NullPointerException();
final ReentrantLock lock = this.lock;
lock.lock();
try {
boolean ok = q.offer(o);
assert ok;
notEmpty.signal();
return true;
} finally {
lock.unlock();
}
|
| public boolean | offer(E o, long timeout, java.util.concurrent.TimeUnit unit)Inserts the specified element into this priority queue. As the queue is
unbounded this method will never block.
return offer(o); // never need to block
|
| public E | peek()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.peek();
} finally {
lock.unlock();
}
|
| public E | poll()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.poll();
} finally {
lock.unlock();
}
|
| public E | poll(long timeout, java.util.concurrent.TimeUnit unit)
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
E x = q.poll();
if (x != null)
return x;
if (nanos <= 0)
return null;
try {
nanos = notEmpty.awaitNanos(nanos);
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
}
} finally {
lock.unlock();
}
|
| public void | put(E o)Adds the specified element to this priority queue. As the queue is
unbounded this method will never block.
offer(o); // never need to block
|
| public int | remainingCapacity()Always returns Integer.MAX_VALUE because
a PriorityBlockingQueue 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 {
try {
while (q.size() == 0)
notEmpty.await();
} catch (InterruptedException ie) {
notEmpty.signal(); // propagate to non-interrupted thread
throw ie;
}
E x = q.poll();
assert x != null;
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[] a)
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.toArray(a);
} finally {
lock.unlock();
}
|
| public java.lang.String | toString()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.toString();
} finally {
lock.unlock();
}
|
| private void | writeObject(java.io.ObjectOutputStream s)Save the state to a stream (that is, serialize it). This
merely wraps default serialization within lock. The
serialization strategy for items is left to underlying
Queue. Note that locking is not needed on deserialization, so
readObject is not defined, just relying on default.
lock.lock();
try {
s.defaultWriteObject();
} finally {
lock.unlock();
}
|
