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, toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear, isEmpty
contains, containsAll, equals, hashCode, isEmpty, parallelStream, remove, removeAll, removeIf, retainAll, spliterator, stream, toArray, toArray
protected 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)
MessagePassingQueue
Queue.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()
MessagePassingQueue
size
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()
QueueProgressIndicators
currentProducerIndex
in interface QueueProgressIndicators
public long currentConsumerIndex()
QueueProgressIndicators
currentConsumerIndex
in interface QueueProgressIndicators
public int capacity()
capacity
in interface MessagePassingQueue<E>
public boolean relaxedOffer(E e)
MessagePassingQueue
Queue.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()
MessagePassingQueue
Queue.poll()
this method may return null without the queue being empty.relaxedPoll
in interface MessagePassingQueue<E>
public E relaxedPeek()
MessagePassingQueue
Queue.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());
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>
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);
}
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>
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.