Package rx.internal.util.unsafe

Class SpscUnboundedArrayQueue<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractQueue<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueueProducerFields<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueueProducerColdFields<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueueL2Pad<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueueConsumerColdField<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueueConsumerField<E>
rx.internal.util.unsafe.SpscUnboundedArrayQueue<E>
All Implemented Interfaces:
Iterable<E>, Collection<E>, Queue<E>, QueueProgressIndicators
@SuppressAnimalSniffer public class SpscUnboundedArrayQueue<E> extends SpscUnboundedArrayQueueConsumerField<E> implements QueueProgressIndicators

  • Field Details

    • MAX_LOOK_AHEAD_STEP

      static final int MAX_LOOK_AHEAD_STEP

    • P_INDEX_OFFSET

      private static final long P_INDEX_OFFSET

    • C_INDEX_OFFSET

      private static final long C_INDEX_OFFSET

    • REF_ARRAY_BASE

      private static final long REF_ARRAY_BASE

    • REF_ELEMENT_SHIFT

      private static final int REF_ELEMENT_SHIFT

    • HAS_NEXT

      private static final Object HAS_NEXT

  • Constructor Details

    • SpscUnboundedArrayQueue

      public SpscUnboundedArrayQueue(int bufferSize)

  • Method Details

    • iterator

      public final Iterator<E> iterator()
      Specified by:
      iterator in interface Collection<E>
      Specified by:
      iterator in interface Iterable<E>
      Specified by:
      iterator in class AbstractCollection<E>

    • offer

      public final boolean offer(E e)

      This implementation is correct for single producer thread use only.

      Specified by:
      offer in interface Queue<E>

    • writeToQueue

      private boolean writeToQueue(E[] buffer, E e, long index, long offset)

    • resize

      private void resize(E[] oldBuffer, long currIndex, long offset, E e, long mask)

    • soNext

      private void soNext(E[] curr, E[] next)

    • lvNext

      private E[] lvNext(E[] curr)

    • poll

      public final E poll()

      This implementation is correct for single consumer thread use only.

      Specified by:
      poll in interface Queue<E>

    • newBufferPoll

      private E newBufferPoll(E[] nextBuffer, long index, long mask)

    • peek

      public final E peek()

      This implementation is correct for single consumer thread use only.

      Specified by:
      peek in interface Queue<E>

    • newBufferPeek

      private E newBufferPeek(E[] nextBuffer, long index, long mask)

    • size

      public final int size()
      Specified by:
      size in interface Collection<E>
      Specified by:
      size in class AbstractCollection<E>

    • adjustLookAheadStep

      private void adjustLookAheadStep(int capacity)

    • lvProducerIndex

      private long lvProducerIndex()

    • lvConsumerIndex

      private long lvConsumerIndex()

    • soProducerIndex

      private void soProducerIndex(long v)

    • soConsumerIndex

      private void soConsumerIndex(long v)

    • calcWrappedOffset

      private static long calcWrappedOffset(long index, long mask)

    • calcDirectOffset

      private static long calcDirectOffset(long index)

    • soElement

      private static void soElement(Object[] buffer, long offset, Object e)

    • lvElement

      private static <E> Object lvElement(E[] buffer, long offset)

    • currentProducerIndex

      public long currentProducerIndex()
      Description copied from interface: QueueProgressIndicators
      This method has no concurrent visibility semantics. The value returned may be negative. Under normal circumstances 2 consecutive calls to this method can offer an idea of progress made by producer threads by subtracting the 2 results though in extreme cases (if producers have progressed by more than 2^64) this may also fail.
      This value will normally indicate number of elements passed into the queue, but may under some circumstances be a derivative of that figure. This method should not be used to derive size or emptiness.
      Specified by:
      currentProducerIndex in interface QueueProgressIndicators
      Returns:
      the current value of the producer progress index

    • currentConsumerIndex

      public long currentConsumerIndex()
      Description copied from interface: QueueProgressIndicators
      This method has no concurrent visibility semantics. The value returned may be negative. Under normal circumstances 2 consecutive calls to this method can offer an idea of progress made by consumer threads by subtracting the 2 results though in extreme cases (if consumers have progressed by more than 2^64) this may also fail.
      This value will normally indicate number of elements taken out of the queue, but may under some circumstances be a derivative of that figure. This method should not be used to derive size or emptiness.
      Specified by:
      currentConsumerIndex in interface QueueProgressIndicators
      Returns:
      the current value of the consumer progress index