public class MpscUnboundedArrayQueue<E> extends AbstractQueue<E>
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
protected E[] |
consumerBuffer |
protected long |
consumerMask |
protected E[] |
producerBuffer |
protected long |
producerMask |
UNBOUNDED_CAPACITY| Constructor and Description |
|---|
MpscUnboundedArrayQueue(int chunkSize) |
| Modifier and Type | Method and Description |
|---|---|
protected long |
availableInQueue(long pIndex,
long cIndex) |
int |
capacity() |
long |
currentConsumerIndex()
This method has no concurrent visibility semantics.
|
long |
currentProducerIndex()
This method has no concurrent visibility semantics.
|
int |
drain(MessagePassingQueue.Consumer<E> c)
Remove all available item from the queue and hand to consume.
|
int |
drain(MessagePassingQueue.Consumer<E> c,
int limit)
Remove up to limit elements from the queue and hand to consume.
|
void |
drain(MessagePassingQueue.Consumer<E> c,
MessagePassingQueue.WaitStrategy wait,
MessagePassingQueue.ExitCondition exit)
Remove elements from the queue and hand to consume forever.
|
int |
fill(MessagePassingQueue.Supplier<E> s)
Stuff the queue with elements from the supplier.
|
int |
fill(MessagePassingQueue.Supplier<E> s,
int limit)
Stuff the queue with up to limit elements from the supplier.
|
void |
fill(MessagePassingQueue.Supplier<E> s,
MessagePassingQueue.WaitStrategy wait,
MessagePassingQueue.ExitCondition exit)
Stuff the queue with elements from the supplier forever.
|
protected long |
getCurrentBufferCapacity(long mask) |
protected int |
getNextBufferSize(E[] buffer) |
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is
carried out.
|
Iterator<E> |
iterator()
Get an iterator for this queue.
|
long |
lvConsumerIndex() |
long |
lvProducerIndex() |
boolean |
offer(E e)
Called from a producer thread subject to the restrictions appropriate to the implementation and
according to the
Queue.offer(Object) interface. |
E |
peek()
Called from the consumer thread subject to the restrictions appropriate to the implementation
and according to the
Queue.peek() interface. |
E |
poll()
Called from the consumer thread subject to the restrictions appropriate to the implementation
and according to the
Queue.poll() interface. |
boolean |
relaxedOffer(E e)
Called from a producer thread subject to the restrictions appropriate to the implementation.
|
E |
relaxedPeek()
Called from the consumer thread subject to the restrictions appropriate to the implementation.
|
E |
relaxedPoll()
Called from the consumer thread subject to the restrictions appropriate to the implementation.
|
int |
size()
This method's accuracy is subject to concurrent modifications happening as the size is
estimated and as such is a best effort rather than absolute value.
|
String |
toString() |
contains, containsAll, remove, removeAll, retainAll, toArray, toArrayclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitclearcontains, containsAll, equals, hashCode, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, stream, toArray, toArrayprotected long producerMask
protected E[] producerBuffer
protected long consumerMask
protected E[] consumerBuffer
protected long availableInQueue(long pIndex,
long cIndex)
public int capacity()
capacity in interface MessagePassingQueue<E>MessagePassingQueue.UNBOUNDED_CAPACITY if not
boundedpublic int drain(MessagePassingQueue.Consumer<E> c)
MessagePassingQueue
M m;
while((m = relaxedPoll()) != null){
c.accept(m);
}
There's no strong commitment to the queue being empty at the end of a drain. Called from a
consumer thread subject to the restrictions appropriate to the implementation.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make
sure you have read and understood these before using this method.
drain in interface MessagePassingQueue<E>public int fill(MessagePassingQueue.Supplier<E> s)
MessagePassingQueuewhile(relaxedOffer(s.get());There's no strong commitment to the queue being full at the end of a fill. Called from a producer thread subject to the restrictions appropriate to the implementation.
Unbounded queues will fill up the queue with a fixed amount rather than fill up to oblivion.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure
you have read and understood these before using this method.
fill in interface MessagePassingQueue<E>protected int getNextBufferSize(E[] buffer)
protected long getCurrentBufferCapacity(long mask)
public int size()
MessagePassingQueuesize in interface MessagePassingQueue<E>size in interface Collection<E>size in class AbstractCollection<E>Integer.MAX_VALUE but less or
equals to capacity (if bounded).public boolean isEmpty()
MessagePassingQueueisEmpty in interface MessagePassingQueue<E>isEmpty in interface Collection<E>isEmpty in class AbstractCollection<E>public String toString()
toString in class AbstractCollection<E>public boolean offer(E e)
MessagePassingQueueQueue.offer(Object) interface.offer in interface MessagePassingQueue<E>offer in interface Queue<E>e - not null, will throw NPE if it ispublic E poll()
Queue.poll() interface.
This implementation is correct for single consumer thread use only.
poll in interface MessagePassingQueue<E>poll in interface Queue<E>null iff emptypublic E peek()
Queue.peek() interface.
This implementation is correct for single consumer thread use only.
peek in interface MessagePassingQueue<E>peek in interface Queue<E>null iff emptypublic long currentProducerIndex()
QueueProgressIndicatorscurrentProducerIndex in interface QueueProgressIndicatorspublic long currentConsumerIndex()
QueueProgressIndicatorscurrentConsumerIndex in interface QueueProgressIndicatorspublic boolean relaxedOffer(E e)
MessagePassingQueueQueue.offer(Object) this method may return false without the queue being
full.relaxedOffer in interface MessagePassingQueue<E>e - not null, will throw NPE if it ispublic E relaxedPoll()
MessagePassingQueueQueue.poll() this method may return null without the queue being
empty.relaxedPoll in interface MessagePassingQueue<E>null if unable to pollpublic E relaxedPeek()
MessagePassingQueueQueue.peek() this method may return null without the queue being
empty.relaxedPeek in interface MessagePassingQueue<E>null if unable to peekpublic int fill(MessagePassingQueue.Supplier<E> s, int limit)
MessagePassingQueue
for(int i=0; i < limit && relaxedOffer(s.get()); i++);
There's no strong commitment to the queue being full at the end of a fill. Called from a producer thread subject to the restrictions appropriate to the implementation.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure
you have read and understood these before using this method.
fill in interface MessagePassingQueue<E>public void fill(MessagePassingQueue.Supplier<E> s, MessagePassingQueue.WaitStrategy wait, MessagePassingQueue.ExitCondition exit)
MessagePassingQueue
int idleCounter = 0;
while (exit.keepRunning()) {
E e = s.get();
while (!relaxedOffer(e)) {
idleCounter = wait.idle(idleCounter);
continue;
}
idleCounter = 0;
}
Called from a producer thread subject to the restrictions appropriate to the implementation.
The main difference being that implementors MUST assure room in the queue is available BEFORE
calling MessagePassingQueue.Supplier.get().
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure
you have read and understood these before using this method.
fill in interface MessagePassingQueue<E>public int drain(MessagePassingQueue.Consumer<E> c, int limit)
MessagePassingQueue
M m;
int i = 0;
for(;i < limit && (m = relaxedPoll()) != null; i++){
c.accept(m);
}
return i;
There's no strong commitment to the queue being empty at the end of a drain. Called from a consumer thread subject to the restrictions appropriate to the implementation.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make
sure you have read and understood these before using this method.
drain in interface MessagePassingQueue<E>public void drain(MessagePassingQueue.Consumer<E> c, MessagePassingQueue.WaitStrategy wait, MessagePassingQueue.ExitCondition exit)
MessagePassingQueue
int idleCounter = 0;
while (exit.keepRunning()) {
E e = relaxedPoll();
if(e==null){
idleCounter = wait.idle(idleCounter);
continue;
}
idleCounter = 0;
c.accept(e);
}
Called from a consumer thread subject to the restrictions appropriate to the implementation.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make
sure you have read and understood these before using this method.
drain in interface MessagePassingQueue<E>public Iterator<E> iterator()
The iterator provides a best-effort snapshot of the elements in the queue. The returned iterator is not guaranteed to return elements in queue order, and races with the consumer thread may cause gaps in the sequence of returned elements. Like {link #relaxedPoll}, the iterator may not immediately return newly inserted elements.
iterator in interface Iterable<E>iterator in interface Collection<E>iterator in class AbstractCollection<E>public final long lvConsumerIndex()
public final long lvProducerIndex()