Class MpscUnboundedXaddArrayQueue<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
org.jctools.queues.MpUnboundedXaddArrayQueuePad1<E>
org.jctools.queues.MpUnboundedXaddArrayQueueProducerFields<E>
org.jctools.queues.MpUnboundedXaddArrayQueuePad2<E>
org.jctools.queues.MpUnboundedXaddArrayQueueProducerChunk<MpscUnboundedXaddChunk<E>, E>
org.jctools.queues.MpUnboundedXaddArrayQueuePad3<MpscUnboundedXaddChunk<E>, E>
org.jctools.queues.MpUnboundedXaddArrayQueueConsumerFields<MpscUnboundedXaddChunk<E>, E>
org.jctools.queues.MpUnboundedXaddArrayQueuePad5<MpscUnboundedXaddChunk<E>, E>
org.jctools.queues.MpUnboundedXaddArrayQueue<MpscUnboundedXaddChunk<E>, E>
org.jctools.queues.MpscUnboundedXaddArrayQueue<E>
All Implemented Interfaces:
Iterable<E>, Collection<E>, Queue<E>, IndexedQueueSizeUtil.IndexedQueue, MessagePassingQueue<E>, QueueProgressIndicators
public class MpscUnboundedXaddArrayQueue<E> extends MpUnboundedXaddArrayQueue<MpscUnboundedXaddChunk<E>, E>
An MPSC array queue which grows unbounded in linked chunks.
Differently from MpscUnboundedArrayQueue it is designed to provide a better scaling when more producers are concurrently offering.
Users should be aware that poll() could spin while awaiting a new element to be available: to avoid this behaviour relaxedPoll() should be used instead, accounting for the semantic differences between the twos.

  • Constructor Details

    • MpscUnboundedXaddArrayQueue

      public MpscUnboundedXaddArrayQueue(int chunkSize, int maxPooledChunks)
      Parameters:
      chunkSize - The buffer size to be used in each chunk of this queue
      maxPooledChunks - The maximum number of reused chunks kept around to avoid allocation, chunks are pre-allocated

    • MpscUnboundedXaddArrayQueue

      public MpscUnboundedXaddArrayQueue(int chunkSize)

  • Method Details

    • newChunk

      final MpscUnboundedXaddChunk<E> newChunk(long index, MpscUnboundedXaddChunk<E> prev, int chunkSize, boolean pooled)
      Specified by:
      newChunk in class MpUnboundedXaddArrayQueue<MpscUnboundedXaddChunk<E>, E>

    • offer

      public boolean offer(E e)
      Description copied from interface: MessagePassingQueue
      Called from a producer thread subject to the restrictions appropriate to the implementation and according to the Queue.offer(Object) interface.
      Parameters:
      e - not null, will throw NPE if it is
      Returns:
      true if element was inserted into the queue, false iff full

    • pollNextBuffer

      private MpscUnboundedXaddChunk<E> pollNextBuffer(MpscUnboundedXaddChunk<E> cChunk, long cIndex)

    • spinForNextIfNotEmpty

      private MpscUnboundedXaddChunk<E> spinForNextIfNotEmpty(MpscUnboundedXaddChunk<E> cChunk, long cIndex)

    • poll

      public E poll()
      Description copied from interface: MessagePassingQueue
      Called from the consumer thread subject to the restrictions appropriate to the implementation and according to the Queue.poll() interface.
      Returns:
      a message from the queue if one is available, null iff empty

    • peek

      public E peek()
      Description copied from interface: MessagePassingQueue
      Called from the consumer thread subject to the restrictions appropriate to the implementation and according to the Queue.peek() interface.
      Returns:
      a message from the queue if one is available, null iff empty

    • relaxedPoll

      public E relaxedPoll()
      Description copied from interface: MessagePassingQueue
      Called from the consumer thread subject to the restrictions appropriate to the implementation. As opposed to Queue.poll() this method may return null without the queue being empty.
      Returns:
      a message from the queue if one is available, null if unable to poll

    • relaxedPeek

      public E relaxedPeek()
      Description copied from interface: MessagePassingQueue
      Called from the consumer thread subject to the restrictions appropriate to the implementation. As opposed to Queue.peek() this method may return null without the queue being empty.
      Returns:
      a message from the queue if one is available, null if unable to peek

    • fill

      public int fill(MessagePassingQueue.Supplier<E> s)
      Description copied from interface: MessagePassingQueue
      Stuff the queue with elements from the supplier. Semantically similar to: 
      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.

      Specified by:
      fill in interface MessagePassingQueue<E>
      Overrides:
      fill in class MpUnboundedXaddArrayQueue<MpscUnboundedXaddChunk<E>, E>
      Returns:
      the number of offered elements

    • drain

      public int drain(MessagePassingQueue.Consumer<E> c, int limit)
      Description copied from interface: MessagePassingQueue
      Remove up to limit elements from the queue and hand to consume. This should be semantically similar to: 

        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.

      Specified by:
      drain in interface MessagePassingQueue<E>
      Overrides:
      drain in class MpUnboundedXaddArrayQueue<MpscUnboundedXaddChunk<E>, E>
      Returns:
      the number of polled elements

    • fill

      public int fill(MessagePassingQueue.Supplier<E> s, int limit)
      Description copied from interface: MessagePassingQueue
      Stuff the queue with up to limit elements from the supplier. Semantically similar to: 

        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.

      Returns:
      the number of offered elements