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

EDU.oswego.cs.dl.util.concurrent
public class: BoundedBuffer [javadoc | source]

java.lang.Object
   EDU.oswego.cs.dl.util.concurrent.BoundedBuffer

All Implemented Interfaces:
    BoundedChannel

Efficient array-based bounded buffer class. Adapted from CPJ, chapter 8, which describes design.

[ Introduction to this package. ]

Field Summary
protected final  Object[]	array_
protected  int	takePtr_
protected  int	putPtr_
protected  int	usedSlots_
protected  int	emptySlots_
protected final  Object	putMonitor_	Helper monitor to handle puts.

Constructor:
public BoundedBuffer() { this(DefaultChannelCapacity.get()); } Create a buffer with the current default capacity
public BoundedBuffer(int capacity) throws IllegalArgumentException { if (capacity < = 0) throw new IllegalArgumentException(); array_ = new Object[capacity]; emptySlots_ = capacity; } Create a BoundedBuffer with the given capacity. Throws: IllegalArgumentException - if capacity less or equal to zero * exception: IllegalArgumentException - if capacity less or equal to zero *

Method from EDU.oswego.cs.dl.util.concurrent.BoundedBuffer Summary:
capacity,   extract,   incEmptySlots,   incUsedSlots,   insert,   offer,   peek,   poll,   put,   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.BoundedBuffer Detail:
public int capacity() { return array_.length; }
protected final Object extract() { // mechanics of take --usedSlots_; Object old = array_[takePtr_]; array_[takePtr_] = null; if (++takePtr_ >= array_.length) takePtr_ = 0; return old; }
protected void incEmptySlots() { synchronized(putMonitor_) { ++emptySlots_; putMonitor_.notify(); } }
protected synchronized void incUsedSlots() { ++usedSlots_; notify(); }
protected final void insert(Object x) { // mechanics of put --emptySlots_; array_[putPtr_] = x; if (++putPtr_ >= array_.length) putPtr_ = 0; }
public boolean offer(Object x, long msecs) throws InterruptedException { if (x == null) throw new IllegalArgumentException(); if (Thread.interrupted()) throw new InterruptedException(); synchronized(putMonitor_) { long start = (msecs < = 0)? 0 : System.currentTimeMillis(); long waitTime = msecs; while (emptySlots_ < = 0) { if (waitTime < = 0) return false; try { putMonitor_.wait(waitTime); } catch (InterruptedException ex) { putMonitor_.notify(); throw ex; } waitTime = msecs - (System.currentTimeMillis() - start); } insert(x); } incUsedSlots(); return true; }
public Object peek() { synchronized(this) { if (usedSlots_ > 0) return array_[takePtr_]; else return null; } }
public Object poll(long msecs) throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Object old = null; synchronized(this) { long start = (msecs < = 0)? 0 : System.currentTimeMillis(); long waitTime = msecs; while (usedSlots_ < = 0) { if (waitTime < = 0) return null; try { wait(waitTime); } catch (InterruptedException ex) { notify(); throw ex; } waitTime = msecs - (System.currentTimeMillis() - start); } old = extract(); } incEmptySlots(); return old; }
public void put(Object x) throws InterruptedException { if (x == null) throw new IllegalArgumentException(); if (Thread.interrupted()) throw new InterruptedException(); synchronized(putMonitor_) { while (emptySlots_ < = 0) { try { putMonitor_.wait(); } catch (InterruptedException ex) { putMonitor_.notify(); throw ex; } } insert(x); } incUsedSlots(); }
public synchronized int size() { return usedSlots_; } Return the number of elements in the buffer. This is only a snapshot value, that may change immediately after returning. *
public Object take() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Object old = null; synchronized(this) { while (usedSlots_ < = 0) { try { wait(); } catch (InterruptedException ex) { notify(); throw ex; } } old = extract(); } incEmptySlots(); return old; }