| Methods Summary |
|---|
| public boolean | add(E e)Inserts the specified element into this priority queue.
return offer(e);
|
| public void | clear()Atomically removes all of the elements from this 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 the elements in this queue,
or null if this queue uses the {@linkplain Comparable
natural ordering} of its elements.
return q.comparator();
|
| public boolean | contains(java.lang.Object o)Returns {@code true} if this queue contains the specified element.
More formally, returns {@code true} if and only if this queue contains
at least one element {@code e} such that {@code o.equals(e)}.
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 "weakly consistent"
iterator that will never throw {@link
ConcurrentModificationException}, and guarantees to traverse
elements as they existed upon construction of the iterator, and
may (but is not guaranteed to) reflect any modifications
subsequent to construction.
return new Itr(toArray());
|
| public boolean | offer(E e)Inserts the specified element into this priority queue.
final ReentrantLock lock = this.lock;
lock.lock();
try {
boolean ok = q.offer(e);
assert ok;
notEmpty.signal();
return true;
} finally {
lock.unlock();
}
|
| public boolean | offer(E e, 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(e); // never need to block
|
| public E | peek()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.peek();
} 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 E | poll()
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.poll();
} finally {
lock.unlock();
}
|
| public void | put(E e)Inserts the specified element into this priority queue. As the queue is
unbounded this method will never block.
offer(e); // 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)Removes a single instance of the specified element from this queue,
if it is present. More formally, removes an element {@code e} such
that {@code o.equals(e)}, if this queue contains one or more such
elements. Returns {@code true} if and only if this queue contained
the specified element (or equivalently, if this queue changed as a
result of the call).
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()Returns an array containing all of the elements in this queue.
The returned array elements are in no particular order.
The returned array will be "safe" in that no references to it are
maintained by this queue. (In other words, this method must allocate
a new array). The caller is thus free to modify the returned array.
This method acts as bridge between array-based and collection-based
APIs.
final ReentrantLock lock = this.lock;
lock.lock();
try {
return q.toArray();
} finally {
lock.unlock();
}
|
| public T[] | toArray(T[] a)Returns an array containing all of the elements in this queue; the
runtime type of the returned array is that of the specified array.
The returned array elements are in no particular order.
If the queue fits in the specified array, it is returned therein.
Otherwise, a new array is allocated with the runtime type of the
specified array and the size of this queue.
If this queue fits in the specified array with room to spare
(i.e., the array has more elements than this queue), the element in
the array immediately following the end of the queue is set to
null.
Like the {@link #toArray()} method, this method acts as bridge between
array-based and collection-based APIs. Further, this method allows
precise control over the runtime type of the output array, and may,
under certain circumstances, be used to save allocation costs.
Suppose x is a queue known to contain only strings.
The following code can be used to dump the queue into a newly
allocated array of String:
String[] y = x.toArray(new String[0]);
Note that toArray(new Object[0]) is identical in function to
toArray().
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)Saves the state to a stream (that is, serializes 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();
}
|
