E - public class MpscChunkedArrayQueue<E> extends AbstractQueue<E> implements MessagePassingQueue<E>, QueueProgressIndicators
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
protected E[] |
consumerBuffer |
protected long |
consumerIndex |
protected long |
consumerMask |
protected boolean |
isFixedChunkSize |
protected long |
maxQueueCapacity |
protected E[] |
producerBuffer |
protected long |
producerIndex |
protected long |
producerLimit |
protected long |
producerMask |
UNBOUNDED_CAPACITY| Constructor and Description |
|---|
MpscChunkedArrayQueue(int maxCapacity) |
MpscChunkedArrayQueue(int initialCapacity,
int maxCapacity,
boolean fixedChunkSize) |
| Modifier and Type | Method and Description |
|---|---|
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 w,
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 batchSize)
Stuff the queue with up to limit elements from the supplier.
|
void |
fill(MessagePassingQueue.Supplier<E> s,
MessagePassingQueue.WaitStrategy w,
MessagePassingQueue.ExitCondition exit)
Stuff the queue with elements from the supplier forever.
|
protected long |
getCurrentBufferCapacity(long mask,
long maxQueueCapacity) |
Iterator<E> |
iterator() |
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.
|
contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toStringclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitclear, isEmptycontains, containsAll, equals, hashCode, isEmpty, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, stream, toArray, toArrayprotected long consumerMask
protected E[] consumerBuffer
protected long consumerIndex
protected long maxQueueCapacity
protected long producerMask
protected E[] producerBuffer
protected volatile long producerLimit
protected boolean isFixedChunkSize
protected long producerIndex
public MpscChunkedArrayQueue(int maxCapacity)
public MpscChunkedArrayQueue(int initialCapacity,
int maxCapacity,
boolean fixedChunkSize)
initialCapacity - the queue initial capacity. If chunk size is fixed this will be the chunk size.
Must be 2 or more.maxCapacity - the maximum capacity will be rounded up to the closest power of 2 and will be the
upper limit of number of elements in this queue. Must be 4 or more and round up to a larger
power of 2 than initialCapacity.fixedChunkSize - if true the queue will grow in fixed sized chunks the size of initial capacity,
otherwise chunk size will double on each resize until reaching the maxCapacitypublic final Iterator<E> iterator()
iterator in interface Iterable<E>iterator in interface Collection<E>iterator in class AbstractCollection<E>public boolean offer(E e)
MessagePassingQueueQueue.offer(Object) interface.public E poll()
Queue.poll() interface.
This implementation is correct for single consumer thread use only.
public E peek()
Queue.peek() interface.
This implementation is correct for single consumer thread use only.
public final int size()
MessagePassingQueuesize in interface Collection<E>size in interface MessagePassingQueue<E>size in class AbstractCollection<E>Integer.MAX_VALUE but less or equals to
capacity (if bounded).public long currentProducerIndex()
QueueProgressIndicatorscurrentProducerIndex in interface QueueProgressIndicatorspublic long currentConsumerIndex()
QueueProgressIndicatorscurrentConsumerIndex in interface QueueProgressIndicatorspublic int capacity()
capacity in interface MessagePassingQueue<E>public 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>public E relaxedPeek()
MessagePassingQueueQueue.peek() this method may return null without the queue being empty.relaxedPeek in interface MessagePassingQueue<E>public int fill(MessagePassingQueue.Supplier<E> s, int batchSize)
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.fill in interface MessagePassingQueue<E>protected long getCurrentBufferCapacity(long mask,
long maxQueueCapacity)
public int fill(MessagePassingQueue.Supplier<E> s)
MessagePassingQueue
while(relaxedOffer(s.get());
fill in interface MessagePassingQueue<E>public void fill(MessagePassingQueue.Supplier<E> s, MessagePassingQueue.WaitStrategy w, 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.fill in interface MessagePassingQueue<E>public void drain(MessagePassingQueue.Consumer<E> c, MessagePassingQueue.WaitStrategy w, 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.drain in interface MessagePassingQueue<E>public int drain(MessagePassingQueue.Consumer<E> c)
MessagePassingQueue
M m;
while((m = relaxedPoll()) != null){
c.accept(m);
}
drain in interface MessagePassingQueue<E>public int drain(MessagePassingQueue.Consumer<E> c, int limit)
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.drain in interface MessagePassingQueue<E>Copyright © 2013–2016. All rights reserved.