E - type of the element stored in the Queuepublic class MpmcArrayQueue<E> extends MpmcArrayQueueConsumerField<E> implements QueueProgressIndicators
ConcurrentCircularArrayQueue. This implies that
any and all threads may call the offer/poll/peek methods and correctness is maintained. MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
(package private) long |
p01 |
(package private) long |
p02 |
(package private) long |
p03 |
(package private) long |
p04 |
(package private) long |
p05 |
(package private) long |
p06 |
(package private) long |
p07 |
(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) static int |
RECOMENDED_OFFER_BATCH |
(package private) static int |
RECOMENDED_POLL_BATCH |
p00SEQ_BUFFER_PAD, sequenceBufferbuffer, maskUNBOUNDED_CAPACITY| Constructor and Description |
|---|
MpmcArrayQueue(int capacity) |
| Modifier and Type | Method and Description |
|---|---|
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 limit)
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.
|
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is carried
out.
|
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.
|
private static int |
validateCapacity(int capacity) |
casConsumerIndex, lvConsumerIndexcasProducerIndex, lvProducerIndexcalcSequenceOffset, calcSequenceOffset, lvSequence, soSequencecalcElementOffset, calcElementOffset, capacity, clear, iteratorcontains, containsAll, remove, removeAll, retainAll, toArray, toArray, toStringclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitlong p01
long p02
long p03
long p04
long p05
long p06
long p07
long p10
long p11
long p12
long p13
long p14
long p15
long p16
long p17
static final int RECOMENDED_POLL_BATCH
static final int RECOMENDED_OFFER_BATCH
private static int validateCapacity(int capacity)
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.
Because return null indicates queue is empty we cannot simply rely on next element visibility for poll and must test producer index when next element is not visible.
poll in interface java.util.Queue<E>poll in interface MessagePassingQueue<E>public E peek()
MessagePassingQueueQueue.peek() interface.peek in interface java.util.Queue<E>peek in interface MessagePassingQueue<E>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 long currentProducerIndex()
QueueProgressIndicatorscurrentProducerIndex in interface QueueProgressIndicatorspublic long currentConsumerIndex()
QueueProgressIndicatorscurrentConsumerIndex in interface QueueProgressIndicatorspublic 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 drain(MessagePassingQueue.Consumer<E> c)
MessagePassingQueue
M m;
while((m = relaxedPoll()) != null){
c.accept(m);
}
drain in interface MessagePassingQueue<E>public int fill(MessagePassingQueue.Supplier<E> s)
MessagePassingQueue
while(relaxedOffer(s.get());
fill 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>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.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 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>