Home » concurrent-sources » EDU.oswego.cs.dl.util.concurrent » [javadoc | source]
public class: BoundedLinkedQueue [javadoc | source]

All Implemented Interfaces:

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.
Field Summary
protected  LinkedNode head_    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. 
protected  LinkedNode last_    The last node of list. Put() appends to list, so modifies last_ 
protected final  Object putGuard_    Helper monitor. Ensures that only one put at a time executes. 
protected final  Object takeGuard_    Helper monitor. Protects and provides wait queue for takes * 
protected  int capacity_    Number of elements allowed * 
protected  int putSidePutPermits_    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. 
protected  int takeSidePutPermits_    Number of takes since last reconcile * 
 public BoundedLinkedQueue() 
 public BoundedLinkedQueue(int capacity) 
Method from EDU.oswego.cs.dl.util.concurrent.BoundedLinkedQueue Summary:
allowTake,   capacity,   extract,   insert,   isEmpty,   offer,   peek,   poll,   put,   reconcilePutPermits,   setCapacity,   size,   take
Methods from java.lang.Object:
clone,   equals,   finalize,   getClass,   hashCode,   notify,   notifyAll,   toString,   wait,   wait,   wait
Method from EDU.oswego.cs.dl.util.concurrent.BoundedLinkedQueue Detail:
 protected final  void allowTake() 
    Notify a waiting take if needed *
 public synchronized int capacity() 
    Return the current capacity of this queue *
 protected synchronized Object extract() 
    Main mechanics for take/poll *
 protected  void insert(Object x) 
    Create and insert a node. Call only under synch on putGuard_ *
 public boolean isEmpty() 
 public boolean offer(Object x,
    long msecs) throws InterruptedException 
 public Object peek() 
 public Object poll(long msecs) throws InterruptedException 
 public  void put(Object x) throws InterruptedException 
 protected final int reconcilePutPermits() 
    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.
 public  void setCapacity(int newCapacity) 
    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.
 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. 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.
 public Object take() throws InterruptedException