org.agrona.concurrent

Class OneToOneConcurrentArrayQueue<E>

java.lang.Object

org.agrona.concurrent.AbstractConcurrentArrayQueue<E>

org.agrona.concurrent.OneToOneConcurrentArrayQueue<E>

Type Parameters:

E - type of the elements stored in the Queue.

All Implemented Interfaces:

Iterable<E>, Collection<E>, Queue<E>, Pipe<E>, QueuedPipe<E>

public class OneToOneConcurrentArrayQueue<E>
extends AbstractConcurrentArrayQueue<E>

One producer to one consumer concurrent queue that is array backed. The algorithm is a variation of Fast Flow adapted to work with the Java Memory Model on arrays by using Unsafe.

Field Summary

Fields

Modifier and Type	Field and Description
protected long	head Head index.
protected long	headCache Cached head index.
protected long	sharedHeadCache Shared cached head index.
protected long	tail Tail index.

Fields inherited from class org.agrona.concurrent.AbstractConcurrentArrayQueue

buffer, BUFFER_ARRAY_BASE, capacity, HEAD_OFFSET, SHARED_HEAD_CACHE_OFFSET, SHIFT_FOR_SCALE, TAIL_OFFSET

Constructor Summary

Constructors

Constructor and Description
OneToOneConcurrentArrayQueue(int requestedCapacity) Constructs queue with the requested capacity.

Method Summary

Modifier and Type	Method and Description
int	drain(Consumer<E> elementConsumer) Drain the number of elements present in a collection at the time the operation starts.
int	drain(Consumer<E> elementConsumer, int limit) Drain the minimum of a limit and the number of elements present in a collection at the time the operation starts.
int	drainTo(Collection<? super E> target, int limit) Drain available elements into the provided Collection up to a provided maximum limit of elements.
boolean	offer(E e)
E	poll()

Methods inherited from class org.agrona.concurrent.AbstractConcurrentArrayQueue

add, addAll, addedCount, capacity, clear, contains, containsAll, element, isEmpty, iterator, peek, remainingCapacity, remove, remove, removeAll, removedCount, retainAll, sequenceToBufferOffset, size, toArray, toArray

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Collection

equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable

forEach

Field Detail

head

protected volatile long head

Head index.

tail

protected volatile long tail

Tail index.

headCache

protected long headCache

Cached head index.

sharedHeadCache

protected volatile long sharedHeadCache

Shared cached head index.

Constructor Detail

OneToOneConcurrentArrayQueue

public OneToOneConcurrentArrayQueue(int requestedCapacity)

Constructs queue with the requested capacity.

Parameters:

requestedCapacity - of the queue.

Method Detail

offer

public boolean offer(E e)

poll

public E poll()

drain

public int drain(Consumer<E> elementConsumer)

Drain the number of elements present in a collection at the time the operation starts.

If possible, implementations should use smart batching to best handle burst traffic.

Parameters:

elementConsumer - Consumer for processing elements.

Returns:

the number of elements drained.

drain

public int drain(Consumer<E> elementConsumer,
                 int limit)

Drain the minimum of a limit and the number of elements present in a collection at the time the operation starts.

If possible, implementations should use smart batching to best handle burst traffic.

Parameters:

elementConsumer - Consumer for processing elements.

limit - maximum number of elements to be drained in a drain operation.

Returns:

the number of elements drained.

drainTo

public int drainTo(Collection<? super E> target,
                   int limit)

Drain available elements into the provided Collection up to a provided maximum limit of elements.

If possible, implementations should use smart batching to best handle burst traffic.

Parameters:

target - in to which elements are drained.

limit - maximum number of elements to be drained in a drain operation.

Returns:

the number of elements actually drained.