E
- public abstract class BaseMpscLinkedArrayQueue<E> extends BaseMpscLinkedArrayQueueColdProducerFields<E> implements MessagePassingQueue<E>, QueueProgressIndicators
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy
Modifier and Type | Field and Description |
---|---|
private static int |
CONTINUE_TO_P_INDEX_CAS |
private static java.lang.Object |
JUMP |
private static int |
QUEUE_FULL |
private static int |
QUEUE_RESIZE |
private static int |
RETRY |
producerBuffer, producerMask
p0, p1, p10, p11, p12, p13, p14, p15, p16, p17, p2, p3, p4, p5, p6, p7
consumerBuffer, consumerIndex, consumerMask
p01, p02, p03, p04, p05, p06, p07
producerIndex
UNBOUNDED_CAPACITY
Constructor and Description |
---|
BaseMpscLinkedArrayQueue(int initialCapacity) |
Modifier and Type | Method and Description |
---|---|
protected abstract long |
availableInQueue(long pIndex,
long cIndex) |
abstract 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 abstract long |
getCurrentBufferCapacity(long mask) |
private E[] |
getNextBuffer(E[] buffer,
long mask) |
protected abstract int |
getNextBufferSize(E[] buffer) |
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is carried
out.
|
java.util.Iterator<E> |
iterator() |
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,
long pIndex,
long producerLimit)
We do not inline resize into this method because we do not resize on fill.
|
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 oldMask,
E[] oldBuffer,
long pIndex,
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.
|
java.lang.String |
toString() |
casProducerLimit, lvProducerLimit, soProducerLimit
lvConsumerIndex, soConsumerIndex
casProducerIndex, lvProducerIndex, soProducerIndex
contains, containsAll, remove, removeAll, retainAll, toArray, toArray
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear
private static final java.lang.Object JUMP
private static final int CONTINUE_TO_P_INDEX_CAS
private static final int RETRY
private static final int QUEUE_FULL
private static final int QUEUE_RESIZE
public BaseMpscLinkedArrayQueue(int initialCapacity)
initialCapacity
- the queue initial capacity. If chunk size is fixed this will be the chunk size.
Must be 2 or more.public final java.util.Iterator<E> iterator()
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).public final boolean isEmpty()
MessagePassingQueue
isEmpty
in interface java.util.Collection<E>
isEmpty
in interface MessagePassingQueue<E>
isEmpty
in class java.util.AbstractCollection<E>
public java.lang.String toString()
toString
in class java.util.AbstractCollection<E>
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 ispublic 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 int offerSlowPath(long mask, long pIndex, long producerLimit)
protected abstract long availableInQueue(long pIndex, long cIndex)
private long nextArrayOffset(long mask)
private long newBufferAndOffset(E[] nextBuffer, long index)
public long currentProducerIndex()
QueueProgressIndicators
currentProducerIndex
in interface QueueProgressIndicators
public long currentConsumerIndex()
QueueProgressIndicators
currentConsumerIndex
in interface QueueProgressIndicators
public abstract int capacity()
capacity
in interface MessagePassingQueue<E>
MessagePassingQueue.UNBOUNDED_CAPACITY
if not boundedpublic 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)
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 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>
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 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;
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.
drain
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>
protected abstract int getNextBufferSize(E[] buffer)
protected abstract long getCurrentBufferCapacity(long mask)