public class MpscBlockingConsumerArrayQueue<E> extends AbstractQueue<E> implements MessagePassingQueue<E>, QueueProgressIndicators, BlockingQueue<E>
BlockingQueue on the consumer side only on top
of the mechanics described in BaseMpscLinkedArrayQueue, but with the reservation bit used for blocking rather
than resizing in this instance.MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy| Modifier and Type | Field and Description |
|---|---|
protected E[] |
consumerBuffer |
protected long |
consumerMask |
protected E[] |
producerBuffer |
protected long |
producerMask |
UNBOUNDED_CAPACITY| Constructor and Description |
|---|
MpscBlockingConsumerArrayQueue(int capacity) |
| Modifier and Type | Method and Description |
|---|---|
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.
|
int |
drain(MessagePassingQueue.Consumer<E> c,
int limit,
long timeout,
TimeUnit unit)
Remove up to limit elements from the queue and hand to consume, waiting up to the specified wait time if
necessary for an element to become available.
|
void |
drain(MessagePassingQueue.Consumer<E> c,
MessagePassingQueue.WaitStrategy w,
MessagePassingQueue.ExitCondition exit)
Remove elements from the queue and hand to consume forever.
|
int |
drainTo(Collection<? super E> c) |
int |
drainTo(Collection<? super E> c,
int maxElements) |
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.
|
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is carried
out.
|
Iterator<E> |
iterator() |
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. |
boolean |
offer(E e,
long timeout,
TimeUnit unit) |
boolean |
offerIfBelowThreshold(E e,
int threshold)
|
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. |
E |
poll(long timeout,
TimeUnit unit) |
void |
put(E e) |
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 |
remainingCapacity() |
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.
|
E |
take() |
String |
toString() |
contains, containsAll, remove, removeAll, retainAll, toArray, toArrayclone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, waitclearadd, contains, removeaddAll, clear, containsAll, equals, hashCode, parallelStream, removeAll, removeIf, retainAll, spliterator, stream, toArray, toArrayprotected final long consumerMask
protected final E[] consumerBuffer
protected final long producerMask
protected final E[] producerBuffer
public MpscBlockingConsumerArrayQueue(int capacity)
public final Iterator<E> iterator()
iterator in interface Iterable<E>iterator in interface Collection<E>iterator in class AbstractCollection<E>public final int size()
MessagePassingQueuesize in interface Collection<E>size in interface MessagePassingQueue<E>size in class AbstractCollection<E>Integer.MAX_VALUE but less or equals to
capacity (if bounded).public final boolean isEmpty()
MessagePassingQueueisEmpty in interface Collection<E>isEmpty in interface MessagePassingQueue<E>isEmpty in class AbstractCollection<E>public String toString()
toString in class AbstractCollection<E>public boolean offerIfBelowThreshold(E e, int threshold)
e - the object to offer onto the queue, not nullthreshold - the maximum allowable sizepublic boolean offer(E e)
MessagePassingQueueQueue.offer(Object) interface.offer in interface BlockingQueue<E>offer in interface Queue<E>offer in interface MessagePassingQueue<E>e - not null, will throw NPE if it ispublic void put(E e) throws InterruptedException
put in interface BlockingQueue<E>InterruptedExceptionpublic boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException
offer in interface BlockingQueue<E>InterruptedExceptionpublic E take() throws InterruptedException
This implementation is correct for single consumer thread use only.
take in interface BlockingQueue<E>InterruptedExceptionpublic E poll(long timeout, TimeUnit unit) throws InterruptedException
This implementation is correct for single consumer thread use only.
poll in interface BlockingQueue<E>InterruptedExceptionpublic int remainingCapacity()
remainingCapacity in interface BlockingQueue<E>public int drainTo(Collection<? super E> c)
drainTo in interface BlockingQueue<E>public int drainTo(Collection<? super E> c, int maxElements)
drainTo in interface BlockingQueue<E>public E poll()
Queue.poll() interface.
This implementation is correct for single consumer thread use only.
public E peek()
Queue.peek() interface.
This implementation is correct for single consumer thread use only.
public long currentProducerIndex()
QueueProgressIndicatorscurrentProducerIndex in interface QueueProgressIndicatorspublic long currentConsumerIndex()
QueueProgressIndicatorscurrentConsumerIndex in interface QueueProgressIndicatorspublic 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, 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 int drain(MessagePassingQueue.Consumer<E> c, int limit, long timeout, TimeUnit unit) throws InterruptedException
There's no strong commitment to the queue being empty at the end of it. This implementation is correct for single consumer thread use only.
WARNING: Explicit assumptions are made with regards to Consumer#accept make sure you have read
and understood these before using this method.
InterruptedException - if interrupted while waitingIllegalArgumentException - c is nullIllegalArgumentException - if limit is negativepublic 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 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 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.
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 final long lvConsumerIndex()
public final long lvProducerIndex()
Copyright © 2013–2024. All rights reserved.