| java.lang.Object
 org.dbunit.util.concurrent.BoundedLinkedQueue
| BoundedLinkedQueue | | public class BoundedLinkedQueue implements BoundedChannel(Code) | | A bounded variant of
LinkedQueue
class. This class may be
preferable to
BoundedBuffer
because it allows a bit more
concurency among puts and takes, because it does not
pre-allocate fixed storage for elements, and allows
capacity to be dynamically reset.
On the other hand, since it allocates a node object
on each put, it can be slow on systems with slow
allocation and GC.
Also, it may be
preferable to
LinkedQueue
when you need to limit
the capacity to prevent resource exhaustion. This protection
normally does not hurt much performance-wise: When the
queue is not empty or full, most puts and
takes are still usually able to execute concurrently.
See Also: LinkedQueue
See Also:
See Also: BoundedBuffer
See Also:
See Also: [ Introduction to this package. ] |
| Method Summary | |
| final protected void | allowTake()
| | public synchronized int | capacity()
| | protected synchronized Object | extract()
| | protected void | insert(Object x)
Create and insert a node. | | public boolean | isEmpty()
| | public boolean | offer(Object x, long msecs)
| | public Object | peek()
| | public Object | poll(long msecs)
| | public void | put(Object x)
| | final protected int | reconcilePutPermits()
Move put permits from take side to put side;
return the number of put side permits that are available. | | public void | setCapacity(int newCapacity)
Reset the capacity of this queue. | | public synchronized int | size()
Return the number of elements in the queue.
This is only a snapshot value, that may be in the midst
of changing. | | public Object | take()
|
| capacity_ | | protected int capacity_(Code) | | Number of elements allowed *
|
| head_ | | protected LinkedNode head_(Code) | | Dummy header node of list. The first actual node, if it exists, is always
at head_.next. After each take, the old first node becomes the head.
|
| last_ | | protected LinkedNode last_(Code) | | The last node of list. Put() appends to list, so modifies last_
|
| putGuard_ | | final protected Object putGuard_(Code) | | Helper monitor. Ensures that only one put at a time executes.
|
| putSidePutPermits_ | | protected int putSidePutPermits_(Code) | | One side of a split permit count.
The counts represent permits to do a put. (The queue is full when zero).
Invariant: putSidePutPermits_ + takeSidePutPermits_ = capacity_ - length.
(The length is never separately recorded, so this cannot be
checked explicitly.)
To minimize contention between puts and takes, the
put side uses up all of its permits before transfering them from
the take side. The take side just increments the count upon each take.
Thus, most puts and take can run independently of each other unless
the queue is empty or full.
Initial value is queue capacity.
|
| takeGuard_ | | final protected Object takeGuard_(Code) | | Helper monitor. Protects and provides wait queue for takes
|
| takeSidePutPermits_ | | protected int takeSidePutPermits_(Code) | | Number of takes since last reconcile *
|
| BoundedLinkedQueue | | public BoundedLinkedQueue(int capacity)(Code) | | Create a queue with the given capacity
exception:
IllegalArgumentException - if capacity less or equal to zero |
| BoundedLinkedQueue | | public BoundedLinkedQueue()(Code) | | Create a queue with the current default capacity
|
| allowTake | | final protected void allowTake()(Code) | | Notify a waiting take if needed *
|
| capacity | | public synchronized int capacity()(Code) | | Return the current capacity of this queue *
|
| extract | | protected synchronized Object extract()(Code) | | Main mechanics for take/poll *
|
| insert | | protected void insert(Object x)(Code) | | Create and insert a node.
Call only under synch on putGuard_
|
| isEmpty | | public boolean isEmpty()(Code) | | |
| reconcilePutPermits | | final protected int reconcilePutPermits()(Code) | | Move put permits from take side to put side;
return the number of put side permits that are available.
Call only under synch on puGuard_ AND this.
|
| setCapacity | | public void setCapacity(int newCapacity)(Code) | | Reset the capacity of this queue.
If the new capacity is less than the old capacity,
existing elements are NOT removed, but
incoming puts will not proceed until the number of elements
is less than the new capacity.
exception:
IllegalArgumentException - if capacity less or equal to zero |
| size | | public synchronized int size()(Code) | | Return the number of elements in the queue.
This is only a snapshot value, that may be in the midst
of changing. The returned value will be unreliable in the presence of
active puts and takes, and should only be used as a heuristic
estimate, for example for resource monitoring purposes.
|
|
|