abstract class BaseMpscLinkedUnpaddedArrayQueue<E> extends BaseMpscLinkedUnpaddedArrayQueueColdProducerFields<E> implements MessagePassingQueue<E>, QueueProgressIndicators
| Modifier and Type | Class and Description |
|---|---|
private static class |
BaseMpscLinkedUnpaddedArrayQueue.WeakIterator<E> |
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
private static java.lang.Object |
BUFFER_CONSUMED |
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, producerMaskconsumerBuffer, consumerMaskUNBOUNDED_CAPACITY| Constructor and Description |
|---|
BaseMpscLinkedUnpaddedArrayQueue(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 wait,
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 limit)
Stuff the queue with up to limit elements from the supplier.
|
void |
fill(MessagePassingQueue.Supplier<E> s,
MessagePassingQueue.WaitStrategy wait,
MessagePassingQueue.ExitCondition exit)
Stuff the queue with elements from the supplier forever.
|
protected abstract long |
getCurrentBufferCapacity(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()
Get an iterator for this queue.
|
private E |
newBufferPeek(E[] nextBuffer,
long cIndex) |
private E |
newBufferPoll(E[] nextBuffer,
long cIndex) |
private static long |
nextArrayOffset(long mask) |
private E[] |
nextBuffer(E[] buffer,
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,
MessagePassingQueue.Supplier<E> s) |
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, soProducerLimitlpConsumerIndex, lvConsumerIndex, soConsumerIndexcasProducerIndex, lvProducerIndex, soProducerIndexcontains, containsAll, remove, removeAll, retainAll, toArray, toArrayclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitclearprivate static final java.lang.Object JUMP
private static final java.lang.Object BUFFER_CONSUMED
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 BaseMpscLinkedUnpaddedArrayQueue(int initialCapacity)
initialCapacity - the queue initial capacity. If chunk size is fixed this will be the chunk size.
Must be 2 or more.public 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).public boolean isEmpty()
MessagePassingQueueisEmpty 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)
MessagePassingQueueQueue.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>null iff emptypublic 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>null iff emptyprivate int offerSlowPath(long mask,
long pIndex,
long producerLimit)
protected abstract long availableInQueue(long pIndex,
long cIndex)
private static long nextArrayOffset(long mask)
public long currentProducerIndex()
QueueProgressIndicatorscurrentProducerIndex in interface QueueProgressIndicatorspublic long currentConsumerIndex()
QueueProgressIndicatorscurrentConsumerIndex in interface QueueProgressIndicatorspublic abstract int capacity()
capacity in interface IndexedQueueSizeUtil.IndexedQueuecapacity in interface MessagePassingQueue<E>MessagePassingQueue.UNBOUNDED_CAPACITY if not boundedpublic 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>null if unable to pollpublic E relaxedPeek()
MessagePassingQueueQueue.peek() this method may return null without the queue being empty.relaxedPeek in interface MessagePassingQueue<E>null if unable to peekpublic int fill(MessagePassingQueue.Supplier<E> s)
MessagePassingQueuewhile(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.
Unbounded queues will fill up the queue with a fixed amount rather than fill up to oblivion.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure you have read
and understood these before using this method.
fill in interface MessagePassingQueue<E>public int fill(MessagePassingQueue.Supplier<E> s, int limit)
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.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure you have read
and understood these before using this method.
fill in interface MessagePassingQueue<E>public void fill(MessagePassingQueue.Supplier<E> s, MessagePassingQueue.WaitStrategy wait, 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. The main difference
being that implementors MUST assure room in the queue is available BEFORE calling MessagePassingQueue.Supplier.get().
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Supplier.get() make sure you have read
and understood these before using this method.
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.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make sure you have read
and understood these before using this method.
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.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make sure you have read
and understood these before using this method.
drain in interface MessagePassingQueue<E>public void drain(MessagePassingQueue.Consumer<E> c, MessagePassingQueue.WaitStrategy wait, 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.
WARNING: Explicit assumptions are made with regards to MessagePassingQueue.Consumer.accept(T) make sure you have read
and understood these before using this method.
drain in interface MessagePassingQueue<E>public java.util.Iterator<E> iterator()
The iterator provides a best-effort snapshot of the elements in the queue. The returned iterator is not guaranteed to return elements in queue order, and races with the consumer thread may cause gaps in the sequence of returned elements. Like {link #relaxedPoll}, the iterator may not immediately return newly inserted elements.
private void resize(long oldMask,
E[] oldBuffer,
long pIndex,
E e,
MessagePassingQueue.Supplier<E> s)
protected abstract int getNextBufferSize(E[] buffer)
protected abstract long getCurrentBufferCapacity(long mask)