BoundedLinkedQueue

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> edu >> emory >> mathcs >> util >> [ concurrent overview ]

PREV CLASS NEXT CLASS

SUMMARY:

JAVADOC |

Sourc code of edu.emory.mathcs.util.concurrent.BoundedLinkedQueue

SOURCE |

Download edu.emory.mathcs.util.concurrent.BoundedLinkedQueue

DOWNLOAD | NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

edu.emory.mathcs.util.concurrent
Class BoundedLinkedQueue

java.lang.Object
  java.util.AbstractCollection
      edu.emory.mathcs.util.AbstractQueue
          edu.emory.mathcs.util.concurrent.BoundedLinkedQueue

All Implemented Interfaces:: BlockingQueue, java.util.Collection, edu.emory.mathcs.util.Queue

public class BoundedLinkedQueue
extends edu.emory.mathcs.util.AbstractQueue
implements BlockingQueue

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 int capacity_
          Number of elements allowed

protected LinkedNode head_
          Dummy header node of list.

protected LinkedNode last_
          The last node of list.

protected java.lang.Object putGuard_
          Helper monitor.

protected int putSidePutPermits_
          One side of a split permit count.

protected java.lang.Object takeGuard_
          Helper monitor.

protected int takeSidePutPermits_
          Number of takes since last reconcile

Constructor Summary

BoundedLinkedQueue()
          Create a queue with the current default capacity

BoundedLinkedQueue(int capacity)
          Create a queue with the given capacity

Method Summary

protected void allowTake()
          Notify a waiting take if needed

int capacity()
          Return the current capacity of this queue

protected java.lang.Object extract()
          Main mechanics for take/poll

protected void insert(java.lang.Object x)
          Create and insert a node.

boolean isEmpty()
          Test whether this collection is empty, that is, if size() == 0.

java.util.Iterator iterator()
          Obtain an Iterator over this collection.

boolean offer(java.lang.Object x)
          Add the specified element to this queue, if possible.

boolean offer(java.lang.Object x, long timeout, TimeUnit granularity)
          Add the given object to the queue, waiting if necessary up to a specified wait time for space to become available.

java.lang.Object peek()
          Return, but do not remove, an element from the queue, or null if the queue is empty.

java.lang.Object poll()
          Remove and return an element from the queue if one is available.

java.lang.Object poll(long timeout, TimeUnit granularity)
          Retrieve and remove the first element from the queue, waiting if necessary up to a specified wait time if no objects are present on the queue.

void put(java.lang.Object x)
          Add the given object to the queue, waiting if necessary for space to become available.

protected int reconcilePutPermits()
          Move put permits from take side to put side; return the number of put side permits that are available.

int remainingCapacity()
          Return the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit.

void setCapacity(int newCapacity)
          Reset the capacity of this queue.

int size()
          Return the number of elements in the queue.

java.lang.Object take()
          Retrieve and remove the first element from the queue, waiting if no objects are present on the queue.

Methods inherited from class edu.emory.mathcs.util.AbstractQueue

add, clear, element, remove

Methods inherited from class java.util.AbstractCollection

addAll, contains, containsAll, remove, removeAll, retainAll, toArray, toArray, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface edu.emory.mathcs.util.Queue

element, remove

Methods inherited from interface java.util.Collection

add, addAll, clear, contains, containsAll, equals, hashCode, remove, removeAll, retainAll, toArray, toArray

Field Detail

head_

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.

last_

protected LinkedNode last_

The last node of list. Put() appends to list, so modifies last_

putGuard_

protected final java.lang.Object putGuard_

Helper monitor. Ensures that only one put at a time executes.

takeGuard_

protected final java.lang.Object takeGuard_

Helper monitor. Protects and provides wait queue for takes

capacity_

protected int capacity_

Number of elements allowed

putSidePutPermits_

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.

takeSidePutPermits_

protected int takeSidePutPermits_

Number of takes since last reconcile

Constructor Detail

BoundedLinkedQueue

public BoundedLinkedQueue(int capacity)

Create a queue with the given capacity

BoundedLinkedQueue

public BoundedLinkedQueue()

Create a queue with the current default capacity

Method Detail

reconcilePutPermits

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.

capacity

public int capacity()

Return the current capacity of this queue

size

public 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.

Specified by:: size in interface java.util.Collection

remainingCapacity

public int remainingCapacity()

Description copied from interface: BlockingQueue

Return the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or Integer.MAX_VALUE if there is no intrinsic limit. 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.

Specified by:: remainingCapacity in interface BlockingQueue

setCapacity

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.

extract

protected java.lang.Object extract()

Main mechanics for take/poll

peek

public java.lang.Object peek()

Description copied from interface: edu.emory.mathcs.util.Queue

Return, but do not remove, an element from the queue, or null if the queue is empty. This method returns the same object reference that would be returned by by the poll method. The two methods differ in that this method does not remove the element from the queue.

Specified by:: peek in interface edu.emory.mathcs.util.Queue

take

public java.lang.Object take()
                      throws java.lang.InterruptedException

Description copied from interface: BlockingQueue

Retrieve and remove the first element from the queue, waiting if no objects are present on the queue.

Specified by:: take in interface BlockingQueue

poll

public java.lang.Object poll()

Description copied from interface: edu.emory.mathcs.util.Queue

Remove and return an element from the queue if one is available.

Specified by:: poll in interface edu.emory.mathcs.util.Queue

poll

public java.lang.Object poll(long timeout,
                             TimeUnit granularity)
                      throws java.lang.InterruptedException

Description copied from interface: BlockingQueue

Retrieve and remove the first element from the queue, waiting if necessary up to a specified wait time if no objects are present on the queue.

Specified by:: poll in interface BlockingQueue

allowTake

protected final void allowTake()

Notify a waiting take if needed

insert

protected void insert(java.lang.Object x)

Create and insert a node. Call only under synch on putGuard_

put

public void put(java.lang.Object x)
         throws java.lang.InterruptedException

Description copied from interface: BlockingQueue

Add the given object to the queue, waiting if necessary for space to become available.

Specified by:: put in interface BlockingQueue

offer

public boolean offer(java.lang.Object x)

Description copied from interface: edu.emory.mathcs.util.Queue

Add the specified element to this queue, if possible.

Specified by:: offer in interface edu.emory.mathcs.util.Queue

offer

public boolean offer(java.lang.Object x,
                     long timeout,
                     TimeUnit granularity)
              throws java.lang.InterruptedException

Description copied from interface: BlockingQueue

Add the given object to the queue, waiting if necessary up to a specified wait time for space to become available.

Specified by:: offer in interface BlockingQueue

isEmpty

public boolean isEmpty()

Description copied from interface: java.util.Collection

Test whether this collection is empty, that is, if size() == 0.

Specified by:: isEmpty in interface java.util.Collection

iterator

public java.util.Iterator iterator()

Description copied from interface: java.util.Collection

Obtain an Iterator over this collection.

Specified by:: iterator in interface java.util.Collection

Overview

Package

Class

Use

Deprecated

Index

Home >> All >> edu >> emory >> mathcs >> util >> [ concurrent overview ]

PREV CLASS NEXT CLASS

SUMMARY:

JAVADOC |

SOURCE |

DOWNLOAD | NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

Field Summary
`protected int`	`capacity_` Number of elements allowed
`protected LinkedNode`	`head_` Dummy header node of list.
`protected LinkedNode`	`last_` The last node of list.
`protected java.lang.Object`	`putGuard_` Helper monitor.
`protected int`	`putSidePutPermits_` One side of a split permit count.
`protected java.lang.Object`	`takeGuard_` Helper monitor.
`protected int`	`takeSidePutPermits_` Number of takes since last reconcile

Constructor Summary
`BoundedLinkedQueue()` Create a queue with the current default capacity
`BoundedLinkedQueue(int capacity)` Create a queue with the given capacity

Method Summary
`protected void`	`allowTake()` Notify a waiting take if needed
`int`	`capacity()` Return the current capacity of this queue
`protected java.lang.Object`	`extract()` Main mechanics for take/poll
`protected void`	`insert(java.lang.Object x)` Create and insert a node.
`boolean`	`isEmpty()` Test whether this collection is empty, that is, if size() == 0.
`java.util.Iterator`	`iterator()` Obtain an Iterator over this collection.
`boolean`	`offer(java.lang.Object x)` Add the specified element to this queue, if possible.
`boolean`	`offer(java.lang.Object x, long timeout, TimeUnit granularity)` Add the given object to the queue, waiting if necessary up to a specified wait time for space to become available.
`java.lang.Object`	`peek()` Return, but do not remove, an element from the queue, or `null` if the queue is empty.
`java.lang.Object`	`poll()` Remove and return an element from the queue if one is available.
`java.lang.Object`	`poll(long timeout, TimeUnit granularity)` Retrieve and remove the first element from the queue, waiting if necessary up to a specified wait time if no objects are present on the queue.
`void`	`put(java.lang.Object x)` Add the given object to the queue, waiting if necessary for space to become available.
`protected int`	`reconcilePutPermits()` Move put permits from take side to put side; return the number of put side permits that are available.
`int`	`remainingCapacity()` Return the number of elements that this queue can ideally (in the absence of memory or resource constraints) accept without blocking, or `Integer.MAX_VALUE` if there is no intrinsic limit.
`void`	`setCapacity(int newCapacity)` Reset the capacity of this queue.
`int`	`size()` Return the number of elements in the queue.
`java.lang.Object`	`take()` Retrieve and remove the first element from the queue, waiting if no objects are present on the queue.

edu.emory.mathcs.util.concurrent Class BoundedLinkedQueue

head_

last_

putGuard_

takeGuard_

capacity_

putSidePutPermits_

takeSidePutPermits_

BoundedLinkedQueue

BoundedLinkedQueue

reconcilePutPermits

capacity

size

remainingCapacity

setCapacity

extract

peek

take

poll

poll

allowTake

insert

put

offer

offer

isEmpty

iterator

edu.emory.mathcs.util.concurrent
Class BoundedLinkedQueue