abstract class BaseLinkedAtomicQueue<E> extends BaseLinkedAtomicQueuePad2<E>
MessagePassingQueue.Consumer<T>, MessagePassingQueue.ExitCondition, MessagePassingQueue.Supplier<T>, MessagePassingQueue.WaitStrategy
b000, b001, b002, b003, b004, b005, b006, b007, b010, b011, b012, b013, b014, b015, b016, b017, b020, b021, b022, b023, b024, b025, b026, b027, b030, b031, b032, b033, b034, b035, b036, b037, b040, b041, b042, b043, b044, b045, b046, b047, b050, b051, b052, b053, b054, b055, b056, b057, b060, b061, b062, b063, b064, b065, b066, b067, b070, b071, b072, b073, b074, b075, b076, b077, b100, b101, b102, b103, b104, b105, b106, b107, b110, b111, b112, b113, b114, b115, b116, b117, b120, b121, b122, b123, b124, b125, b126, b127, b130, b131, b132, b133, b134, b135, b136, b137, b140, b141, b142, b143, b144, b145, b146, b147, b150, b151, b152, b153, b154, b155, b156, b157, b160, b161, b162, b163, b164, b165, b166, b167, b170, b171, b172, b173, b174, b175, b176, b177
UNBOUNDED_CAPACITY
Constructor and Description |
---|
BaseLinkedAtomicQueue() |
Modifier and Type | Method and Description |
---|---|
int |
capacity() |
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.
|
protected E |
getSingleConsumerNodeValue(LinkedQueueAtomicNode<E> currConsumerNode,
LinkedQueueAtomicNode<E> nextNode) |
boolean |
isEmpty()
This method's accuracy is subject to concurrent modifications happening as the observation is carried
out.
|
java.util.Iterator<E> |
iterator() |
protected LinkedQueueAtomicNode<E> |
newNode() |
protected LinkedQueueAtomicNode<E> |
newNode(E e) |
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.
|
(package private) LinkedQueueAtomicNode<E> |
spinWaitForNextNode(LinkedQueueAtomicNode<E> currNode) |
java.lang.String |
toString() |
lpConsumerNode, lvConsumerNode, spConsumerNode
casProducerNode, lpProducerNode, lvProducerNode, soProducerNode, spProducerNode, xchgProducerNode
contains, containsAll, remove, removeAll, retainAll, toArray, toArray
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait
clear, fill, fill, fill, offer
public final java.util.Iterator<E> iterator()
public java.lang.String toString()
toString
in class java.util.AbstractCollection<E>
protected final LinkedQueueAtomicNode<E> newNode()
protected final LinkedQueueAtomicNode<E> newNode(E e)
public final int size()
IMPLEMENTATION NOTES:
This is an O(n) operation as we run through all the nodes and count them.
The accuracy of the value returned by this method is subject to races with producer/consumer threads. In
particular when racing with the consumer thread this method may under estimate the size.
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).Collection.size()
public boolean isEmpty()
IMPLEMENTATION NOTES:
Queue is empty when producerNode is the same as consumerNode. An alternative implementation would be to
observe the producerNode.value is null, which also means an empty queue because only the
consumerNode.value is allowed to be null.
isEmpty
in interface java.util.Collection<E>
isEmpty
in interface MessagePassingQueue<E>
isEmpty
in class java.util.AbstractCollection<E>
MessagePassingQueue.isEmpty()
protected E getSingleConsumerNodeValue(LinkedQueueAtomicNode<E> currConsumerNode, LinkedQueueAtomicNode<E> nextNode)
public E poll()
Queue.poll()
interface.
IMPLEMENTATION NOTES:
Poll is allowed from a SINGLE thread.
Poll is potentially blocking here as the Queue.poll()
does not allow returning null
if the queue is not
empty. This is very different from the original Vyukov guarantees. See relaxedPoll()
for the original
semantics.
Poll reads consumerNode.next
and:
null
AND the queue is empty return null
, if queue is not empty spin wait for
value to become visible.
null
set it as the consumer node and return it's now evacuated value.
null
, which is also the starting point for the queue.
Because null
values are not allowed to be offered this is the only node with it's value set to
null
at any one time.null
iff emptyMessagePassingQueue.poll()
,
Queue.poll()
public E peek()
Queue.peek()
interface.
IMPLEMENTATION NOTES:
Peek is allowed from a SINGLE thread.
Peek is potentially blocking here as the Queue.peek()
does not allow returning null
if the queue is not
empty. This is very different from the original Vyukov guarantees. See relaxedPeek()
for the original
semantics.
Poll reads the next node from the consumerNode and:
null
AND the queue is empty return null
, if queue is not empty spin wait for
value to become visible.
null
return it's value.
null
iff emptyMessagePassingQueue.peek()
,
Queue.peek()
LinkedQueueAtomicNode<E> spinWaitForNextNode(LinkedQueueAtomicNode<E> currNode)
public E relaxedPoll()
MessagePassingQueue
Queue.poll()
this method may return null
without the queue being empty.null
if unable to pollpublic E relaxedPeek()
MessagePassingQueue
Queue.peek()
this method may return null
without the queue being empty.null
if unable to peekpublic boolean relaxedOffer(E e)
MessagePassingQueue
Queue.offer(Object)
this method may return false without the queue being full.e
- not null
, will throw NPE if it ispublic 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.
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.
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.
public int capacity()
MessagePassingQueue.UNBOUNDED_CAPACITY
if not bounded