| Constructors Summary |
|---|
public PriorityBlockingQueue()Creates a PriorityBlockingQueue with the default initial
capacity
(11) that orders its elements according to their natural
ordering (using Comparable).
q = new PriorityQueue<E>();
|
public PriorityBlockingQueue(int initialCapacity)Creates a PriorityBlockingQueue with the specified initial
capacity
that orders its elements according to their natural ordering
(using Comparable).
q = new PriorityQueue<E>(initialCapacity, null);
|
public PriorityBlockingQueue(int initialCapacity, Comparator comparator)Creates a PriorityBlockingQueue with the specified initial
capacity
that orders its elements according to the specified comparator.
q = new PriorityQueue<E>(initialCapacity, comparator);
|
public PriorityBlockingQueue(Collection c)Creates a PriorityBlockingQueue containing the elements
in the specified collection. The priority queue has an initial
capacity of 110% of the size of the specified collection. If
the specified collection is a {@link SortedSet} or a {@link
PriorityQueue}, this priority queue will be sorted according to
the same comparator, or according to its elements' natural
order if the collection is sorted according to its elements'
natural order. Otherwise, this priority queue is ordered
according to its elements' natural order.
q = new PriorityQueue<E>(c);
|
| 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();
}
|
