public final class MpscRelaxedAtomicArrayQueue<E> extends MpscRelaxedAtomicArrayQueueL3Pad<E> implements MessagePassingQueue<E>
Modifier and Type | Class and Description |
---|---|
private static class |
MpscRelaxedAtomicArrayQueue.AtomicLongArrayAccess |
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy
Modifier and Type | Field and Description |
---|---|
private java.util.concurrent.atomic.AtomicReferenceArray<E> |
buffer |
private int |
capacity |
private int |
cycleIdBitShift |
private int |
cycleLength |
private int |
cycleLengthLog2 |
private long |
mask |
private long |
maxCycleId |
private int |
positionOnCycleMask |
private java.util.concurrent.atomic.AtomicLongArray |
producerCycleClaim |
p01, p02, p03, p04, p05, p06, p07, p10, p11, p12, p13, p14, p15, p16, p17
consumerPosition
p00
UNBOUNDED_CAPACITY
Constructor and Description |
---|
MpscRelaxedAtomicArrayQueue(int capacity) |
Modifier and Type | Method and Description |
---|---|
private static int |
calcElementOffset(int cycle,
int positionWithinCycle,
int cycleLengthLog2) |
private static int |
calcElementOffset(long position,
long mask) |
int |
capacity() |
void |
clear()
Removes all items from the queue.
|
private static long |
cycleId(long producerCycleClaim,
int cycleIdBitShift) |
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.
|
private boolean |
isBackPressured(long producerPosition) |
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is carried
out.
|
java.util.Iterator<E> |
iterator() |
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. |
private E |
pollMaybeEmpty(java.util.concurrent.atomic.AtomicReferenceArray<E> buffer,
int offset,
long consumerPosition) |
private static int |
positionOnCycle(long producerCycleClaim,
int positionOnCycleMask) |
private static long |
producerPosition(long cycleId,
int positionWithinCycle,
int cycleLengthLog2) |
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 |
rotateCycle(java.util.concurrent.atomic.AtomicLongArray producerCycleClaims,
int activeCycle,
long producerCycleClaim,
int cycleIdBitShift,
long maxCycleId) |
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() |
private void |
validateSlowProducerClaim(long cycleId,
int positionOnCycle,
int cycleLengthLog2) |
lvConsumerPosition, soConsumerPosition
lvProducerLimit, soProducerLimit
activeCycleIndex, casActiveCycleId, lvActiveCycleId, soActiveCycleId
contains, containsAll, remove, removeAll, retainAll, toArray, toArray
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
private final long mask
private final int capacity
private final int cycleLength
private final int cycleLengthLog2
private final java.util.concurrent.atomic.AtomicReferenceArray<E> buffer
private final java.util.concurrent.atomic.AtomicLongArray producerCycleClaim
private final int positionOnCycleMask
private final int cycleIdBitShift
private final long maxCycleId
public java.util.Iterator<E> iterator()
private static int positionOnCycle(long producerCycleClaim, int positionOnCycleMask)
private static long cycleId(long producerCycleClaim, int cycleIdBitShift)
private static long producerPosition(long cycleId, int positionWithinCycle, int cycleLengthLog2)
private static int calcElementOffset(int cycle, int positionWithinCycle, int cycleLengthLog2)
private static int calcElementOffset(long position, long mask)
private boolean isBackPressured(long producerPosition)
private void rotateCycle(java.util.concurrent.atomic.AtomicLongArray producerCycleClaims, int activeCycle, long producerCycleClaim, int cycleIdBitShift, long maxCycleId)
private void validateSlowProducerClaim(long cycleId, int positionOnCycle, int cycleLengthLog2)
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()
MessagePassingQueue
Queue.poll()
interface.poll
in interface java.util.Queue<E>
poll
in interface MessagePassingQueue<E>
private E pollMaybeEmpty(java.util.concurrent.atomic.AtomicReferenceArray<E> buffer, int offset, long consumerPosition)
public E peek()
MessagePassingQueue
Queue.peek()
interface.peek
in interface java.util.Queue<E>
peek
in interface MessagePassingQueue<E>
public 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 void clear()
MessagePassingQueue
Collection.clear()
interface.clear
in interface java.util.Collection<E>
clear
in interface MessagePassingQueue<E>
clear
in class java.util.AbstractQueue<E>
public boolean isEmpty()
MessagePassingQueue
isEmpty
in interface java.util.Collection<E>
isEmpty
in interface MessagePassingQueue<E>
isEmpty
in class java.util.AbstractCollection<E>
public 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 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 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 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 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>
public java.lang.String toString()
toString
in class java.util.AbstractCollection<E>