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, consumerMask
isFixedChunkSize, maxQueueCapacity, producerBuffer, producerLimit, producerMask
p01, p02, p03, p04, p05, p06, p07
producerIndex
UNBOUNDED_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, toString
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear, isEmpty
long 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)
MessagePassingQueue
Queue.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()
MessagePassingQueue
size
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()
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>
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());
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>