public class MpscChunkedAtomicArrayQueue<E>
extends java.util.AbstractQueue<E>
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy
限定符和类型 | 字段和说明 |
---|---|
protected java.util.concurrent.atomic.AtomicReferenceArray<E> |
consumerBuffer |
protected long |
consumerMask |
protected long |
maxQueueCapacity |
protected java.util.concurrent.atomic.AtomicReferenceArray<E> |
producerBuffer |
protected long |
producerMask |
UNBOUNDED_CAPACITY
构造器和说明 |
---|
MpscChunkedAtomicArrayQueue(int maxCapacity) |
MpscChunkedAtomicArrayQueue(int initialCapacity,
int maxCapacity) |
限定符和类型 | 方法和说明 |
---|---|
protected long |
availableInQueue(long pIndex,
long cIndex) |
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 long |
getCurrentBufferCapacity(long mask) |
protected int |
getNextBufferSize(java.util.concurrent.atomic.AtomicReferenceArray<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.
|
long |
lvConsumerIndex() |
long |
lvProducerIndex() |
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.
|
java.lang.String |
toString() |
contains, containsAll, remove, removeAll, retainAll, toArray, toArray
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear
protected final long maxQueueCapacity
protected long producerMask
protected java.util.concurrent.atomic.AtomicReferenceArray<E> producerBuffer
protected long consumerMask
protected java.util.concurrent.atomic.AtomicReferenceArray<E> consumerBuffer
public MpscChunkedAtomicArrayQueue(int maxCapacity)
public MpscChunkedAtomicArrayQueue(int initialCapacity, int maxCapacity)
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.protected long availableInQueue(long pIndex, long cIndex)
public int capacity()
capacity
在接口中 MessagePassingQueue<E>
MessagePassingQueue.UNBOUNDED_CAPACITY
if not boundedprotected int getNextBufferSize(java.util.concurrent.atomic.AtomicReferenceArray<E> buffer)
protected long getCurrentBufferCapacity(long mask)
public int size()
MessagePassingQueue
size
在接口中 MessagePassingQueue<E>
size
在接口中 java.util.Collection<E>
size
在类中 java.util.AbstractCollection<E>
Integer.MAX_VALUE
but less or equals to
capacity (if bounded).public boolean isEmpty()
MessagePassingQueue
isEmpty
在接口中 MessagePassingQueue<E>
isEmpty
在接口中 java.util.Collection<E>
isEmpty
在类中 java.util.AbstractCollection<E>
public java.lang.String toString()
toString
在类中 java.util.AbstractCollection<E>
public boolean offer(E e)
MessagePassingQueue
Queue.offer(Object)
interface.offer
在接口中 MessagePassingQueue<E>
offer
在接口中 java.util.Queue<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
在接口中 MessagePassingQueue<E>
poll
在接口中 java.util.Queue<E>
null
iff emptypublic E peek()
Queue.peek()
interface.
This implementation is correct for single consumer thread use only.
peek
在接口中 MessagePassingQueue<E>
peek
在接口中 java.util.Queue<E>
null
iff emptypublic long currentProducerIndex()
QueueProgressIndicators
currentProducerIndex
在接口中 QueueProgressIndicators
public long currentConsumerIndex()
QueueProgressIndicators
currentConsumerIndex
在接口中 QueueProgressIndicators
public boolean relaxedOffer(E e)
MessagePassingQueue
Queue.offer(Object)
this method may return false without the queue being full.relaxedOffer
在接口中 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
在接口中 MessagePassingQueue<E>
null
if unable to pollpublic E relaxedPeek()
MessagePassingQueue
Queue.peek()
this method may return null
without the queue being empty.relaxedPeek
在接口中 MessagePassingQueue<E>
null
if unable to peekpublic 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.
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
在接口中 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
在接口中 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
在接口中 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
在接口中 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
在接口中 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
在接口中 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.
iterator
在接口中 java.lang.Iterable<E>
iterator
在接口中 java.util.Collection<E>
iterator
在类中 java.util.AbstractCollection<E>
public final long lvConsumerIndex()
public final long lvProducerIndex()