E
- the type of elements held in this collectionpublic class VariableLinkedBlockingQueue<E>
extends java.util.AbstractQueue<E>
implements java.util.concurrent.BlockingQueue<E>, java.io.Serializable
setCapacity(int)
method, allowing us to
change the capacity of the queue while it is in use.The documentation for LinkedBlockingQueue follows...
An optionally-bounded blocking queue based on linked nodes. This queue orders elements FIFO (first-in-first-out). The head of the queue is that element that has been on the queue the longest time. The tail of the queue is that element that has been on the queue the shortest time. New elements are inserted at the tail of the queue, and the queue retrieval operations obtain elements at the head of the queue. Linked queues typically have higher throughput than array-based queues but less predictable performance in most concurrent applications.
The optional capacity bound constructor argument serves as a
way to prevent excessive queue expansion. The capacity, if unspecified,
is equal to Integer.MAX_VALUE
. Linked nodes are
dynamically created upon each insertion unless this would bring the
queue above capacity.
This class implements all of the optional methods
of the Collection
and Iterator
interfaces.
This class is a member of the Java Collections Framework.
Constructor and Description |
---|
VariableLinkedBlockingQueue()
Creates a LinkedBlockingQueue with a capacity of
Integer.MAX_VALUE . |
VariableLinkedBlockingQueue(java.util.Collection<? extends E> c)
Creates a LinkedBlockingQueue with a capacity of
Integer.MAX_VALUE , initially containing the elements of the
given collection,
added in traversal order of the collection's iterator. |
VariableLinkedBlockingQueue(int capacity)
Creates a LinkedBlockingQueue with the given (fixed) capacity.
|
Modifier and Type | Method and Description |
---|---|
void |
clear() |
int |
drainTo(java.util.Collection<? super E> c) |
int |
drainTo(java.util.Collection<? super E> c,
int maxElements) |
java.util.Iterator<E> |
iterator()
Returns an iterator over the elements in this queue in proper sequence.
|
boolean |
offer(E o)
Inserts the specified element at the tail of this queue if possible,
returning immediately if this queue is full.
|
boolean |
offer(E o,
long timeout,
java.util.concurrent.TimeUnit unit)
Inserts the specified element at the tail of this queue, waiting if
necessary up to the specified wait time for space to become available.
|
E |
peek() |
E |
poll() |
E |
poll(long timeout,
java.util.concurrent.TimeUnit unit) |
void |
put(E o)
Adds the specified element to the tail of this queue, waiting if
necessary for space to become available.
|
int |
remainingCapacity()
Returns the number of elements that this queue can ideally (in
the absence of memory or resource constraints) accept without
blocking.
|
boolean |
remove(java.lang.Object o) |
void |
setCapacity(int capacity)
Set a new capacity for the queue.
|
int |
size()
Returns the number of elements in this queue.
|
E |
take() |
java.lang.Object[] |
toArray() |
<T> T[] |
toArray(T[] a) |
java.lang.String |
toString() |
contains, containsAll, isEmpty, removeAll, retainAll
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
public VariableLinkedBlockingQueue()
Integer.MAX_VALUE
.public VariableLinkedBlockingQueue(int capacity)
capacity
- the capacity of this queue.java.lang.IllegalArgumentException
- if capacity is not greater
than zero.public VariableLinkedBlockingQueue(java.util.Collection<? extends E> c)
Integer.MAX_VALUE
, initially containing the elements of the
given collection,
added in traversal order of the collection's iterator.c
- the collection of elements to initially containjava.lang.NullPointerException
- if c or any element within it
is nullpublic int size()
public void setCapacity(int capacity)
put(Object)
invocations to succeed if the new
capacity is larger than the queue.capacity
- the new capacity for the queuepublic int remainingCapacity()
Note that you cannot always tell if an attempt to add an element will succeed by inspecting remainingCapacity because it may be the case that a waiting consumer is ready to take an element out of an otherwise full queue.
remainingCapacity
in interface java.util.concurrent.BlockingQueue<E>
public void put(E o) throws java.lang.InterruptedException
put
in interface java.util.concurrent.BlockingQueue<E>
o
- the element to addjava.lang.InterruptedException
- if interrupted while waiting.java.lang.NullPointerException
- if the specified element is null.public boolean offer(E o, long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException
offer
in interface java.util.concurrent.BlockingQueue<E>
o
- the element to addtimeout
- how long to wait before giving up, in units of
unitunit
- a TimeUnit determining how to interpret the
timeout parameterjava.lang.InterruptedException
- if interrupted while waiting.java.lang.NullPointerException
- if the specified element is null.public boolean offer(E o)
offer
in interface java.util.concurrent.BlockingQueue<E>
offer
in interface java.util.Queue<E>
o
- the element to add.java.lang.NullPointerException
- if the specified element is nullpublic E take() throws java.lang.InterruptedException
take
in interface java.util.concurrent.BlockingQueue<E>
java.lang.InterruptedException
public E poll(long timeout, java.util.concurrent.TimeUnit unit) throws java.lang.InterruptedException
poll
in interface java.util.concurrent.BlockingQueue<E>
java.lang.InterruptedException
public boolean remove(java.lang.Object o)
public java.lang.Object[] toArray()
public <T> T[] toArray(T[] a)
public java.lang.String toString()
toString
in class java.util.AbstractCollection<E>
public void clear()
public int drainTo(java.util.Collection<? super E> c)
drainTo
in interface java.util.concurrent.BlockingQueue<E>
public int drainTo(java.util.Collection<? super E> c, int maxElements)
drainTo
in interface java.util.concurrent.BlockingQueue<E>
public java.util.Iterator<E> iterator()
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.