E - public class MpscChunkedArrayQueue<E> extends MpscChunkedArrayQueueConsumerFields<E> implements MessagePassingQueue<E>, QueueProgressIndicators
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
private static long |
C_INDEX_OFFSET |
private static java.lang.Object |
JUMP |
private static long |
P_INDEX_OFFSET |
private static long |
P_LIMIT_OFFSET |
(package private) long |
p0 |
(package private) long |
p1 |
(package private) long |
p10 |
(package private) long |
p11 |
(package private) long |
p12 |
(package private) long |
p13 |
(package private) long |
p14 |
(package private) long |
p15 |
(package private) long |
p16 |
(package private) long |
p17 |
(package private) long |
p2 |
(package private) long |
p3 |
(package private) long |
p4 |
(package private) long |
p5 |
(package private) long |
p6 |
(package private) long |
p7 |
consumerBuffer, consumerIndex, consumerMaskisFixedChunkSize, maxQueueCapacity, producerBuffer, producerLimit, producerMaskp01, p02, p03, p04, p05, p06, p07producerIndexUNBOUNDED_CAPACITY| Constructor and Description |
|---|
MpscChunkedArrayQueue(int maxCapacity) |
MpscChunkedArrayQueue(int initialCapacity,
int maxCapacity,
boolean fixedChunkSize) |
| Modifier and Type | Method and Description |
|---|---|
int |
capacity() |
private boolean |
casProducerIndex(long expect,
long newValue) |
private boolean |
casProducerLimit(long expect,
long newValue) |
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) |
private E[] |
getNextBuffer(E[] buffer,
long mask) |
private int |
getNextBufferCapacity(E[] buffer,
long maxQueueCapacity) |
java.util.Iterator<E> |
iterator() |
private long |
lvConsumerIndex() |
private long |
lvProducerIndex() |
private long |
lvProducerLimit() |
private static long |
modifiedCalcElementOffset(long index,
long mask)
This method assumes index is actually (index << 1) because lower bit is used for resize.
|
private long |
newBufferAndOffset(E[] nextBuffer,
long index) |
private E |
newBufferPeek(E[] nextBuffer,
long index) |
private E |
newBufferPoll(E[] nextBuffer,
long index) |
private long |
nextArrayOffset(long mask) |
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. |
private int |
offerSlowPath(long mask,
E[] buffer,
long pIndex,
long producerLimit) |
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.
|
private void |
resize(long mask,
E[] buffer,
long pIndex,
long consumerIndex,
long maxQueueCapacity,
E e) |
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.
|
private void |
soConsumerIndex(long v) |
private void |
soProducerIndex(long v) |
private void |
soProducerLimit(long v) |
contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toStringclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitclear, isEmptylong p0
long p1
long p2
long p3
long p4
long p5
long p6
long p7
long p10
long p11
long p12
long p13
long p14
long p15
long p16
long p17
private static final long P_INDEX_OFFSET
private static final long C_INDEX_OFFSET
private static final long P_LIMIT_OFFSET
private static final java.lang.Object JUMP
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 java.util.Iterator<E> iterator()
public boolean offer(E e)
MessagePassingQueueQueue.offer(Object) interface.offer in interface java.util.Queue<E>offer in interface MessagePassingQueue<E>e - not null, will throw NPE if it isprivate int offerSlowPath(long mask,
E[] buffer,
long pIndex,
long producerLimit)
private static long modifiedCalcElementOffset(long index,
long mask)
public E poll()
Queue.poll() interface.
This implementation is correct for single consumer thread use only.
poll in interface java.util.Queue<E>poll in interface MessagePassingQueue<E>public E peek()
Queue.peek() interface.
This implementation is correct for single consumer thread use only.
peek in interface java.util.Queue<E>peek in interface MessagePassingQueue<E>private long nextArrayOffset(long mask)
private long newBufferAndOffset(E[] nextBuffer, long index)
public final int size()
MessagePassingQueuesize in interface java.util.Collection<E>size in interface MessagePassingQueue<E>size in class java.util.AbstractCollection<E>Integer.MAX_VALUE but less or equals to
capacity (if bounded).private long lvProducerIndex()
private long lvConsumerIndex()
private void soProducerIndex(long v)
private boolean casProducerIndex(long expect,
long newValue)
private void soConsumerIndex(long v)
private long lvProducerLimit()
private boolean casProducerLimit(long expect,
long newValue)
private void soProducerLimit(long v)
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>private void resize(long mask,
E[] buffer,
long pIndex,
long consumerIndex,
long maxQueueCapacity,
E e)
private int getNextBufferCapacity(E[] buffer, long maxQueueCapacity)
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>