AbstractConcurrentArrayQueue (Agrona)

java.lang.Object
- org.agrona.concurrent.AbstractConcurrentArrayQueue<E>

All Implemented Interfaces:

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

Direct Known Subclasses:

ManyToManyConcurrentArrayQueue, ManyToOneConcurrentArrayQueue, OneToOneConcurrentArrayQueue
```
public abstract class AbstractConcurrentArrayQueue<E>
extends Object
implements QueuedPipe<E>
```
Left over immutable queue fields.

Field Summary

Fields
Modifier and Type	Field and Description
`protected E[]`	`buffer`
`protected static int`	`BUFFER_ARRAY_BASE`
`protected int`	`capacity`
`protected long`	`head`
`protected static long`	`HEAD_OFFSET`
`protected long`	`headCache`
`protected static long`	`SHARED_HEAD_CACHE_OFFSET`
`protected long`	`sharedHeadCache`
`protected static int`	`SHIFT_FOR_SCALE`
`protected long`	`tail`
`protected static long`	`TAIL_OFFSET`

Constructor Summary

Constructors
Constructor and Description

AbstractConcurrentArrayQueue(int requestedCapacity)

Constructors
Constructor and Description
`AbstractConcurrentArrayQueue(int requestedCapacity)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(E e)`
`boolean`	`addAll(Collection<? extends E> c)`
`long`	`addedCount()` The number of items added to this container since creation.
`int`	`capacity()` The maximum capacity of this container to hold items.
`void`	`clear()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`E`	`element()`
`boolean`	`isEmpty()`
`Iterator<E>`	`iterator()`
`E`	`peek()`
`int`	`remainingCapacity()` Get the remaining capacity for elements in the container given the current size.
`E`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`long`	`removedCount()` The number of items removed from this container since creation.
`boolean`	`retainAll(Collection<?> c)`
`static long`	`sequenceToBufferOffset(long sequence, long mask)`
`int`	`size()` The number of items currently in the container.
`Object[]`	`toArray()`
`<T> T[]`	`toArray(T[] a)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Queue
offer, poll

Methods inherited from interface java.util.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface org.agrona.concurrent.Pipe
drain, drain, drainTo

- Field Detail
  - TAIL_OFFSET
```
protected static final long TAIL_OFFSET
```
  - SHARED_HEAD_CACHE_OFFSET
```
protected static final long SHARED_HEAD_CACHE_OFFSET
```
  - HEAD_OFFSET
```
protected static final long HEAD_OFFSET
```
  - BUFFER_ARRAY_BASE
```
protected static final int BUFFER_ARRAY_BASE
```
  - SHIFT_FOR_SCALE
```
protected static final int SHIFT_FOR_SCALE
```
  - capacity
```
protected final int capacity
```
  - buffer
```
protected final E[] buffer
```
  - head
```
protected volatile long head
```
  - tail
```
protected volatile long tail
```
  - headCache
```
protected long headCache
```
  - sharedHeadCache
```
protected volatile long sharedHeadCache
```
- Constructor Detail
  - AbstractConcurrentArrayQueue
```
public AbstractConcurrentArrayQueue(int requestedCapacity)
```
- Method Detail
  - addedCount
```
public long addedCount()
```
    Description copied from interface: Pipe
    
    The number of items added to this container since creation.
    
    Specified by:
    
    addedCount in interface Pipe<E>
    
    Returns:
    
    the number of items added.
  - removedCount
```
public long removedCount()
```
    Description copied from interface: Pipe
    
    The number of items removed from this container since creation.
    
    Specified by:
    
    removedCount in interface Pipe<E>
    
    Returns:
    
    the number of items removed.
  - capacity
```
public int capacity()
```
    Description copied from interface: Pipe
    
    The maximum capacity of this container to hold items.
    
    Specified by:
    
    capacity in interface Pipe<E>
    
    Returns:
    
    the capacity of the container.
  - remainingCapacity
```
public int remainingCapacity()
```
    Description copied from interface: Pipe
    
    Get the remaining capacity for elements in the container given the current size.
    
    Specified by:
    
    remainingCapacity in interface Pipe<E>
    
    Returns:
    
    remaining capacity of the container.
  - peek
```
public E peek()
```
    Specified by:
    
    peek in interface Queue<E>
  - add
```
public boolean add(E e)
```
    Specified by:
    
    add in interface Collection<E>
    
    Specified by:
    
    add in interface Queue<E>
  - remove
```
public E remove()
```
    Specified by:
    
    remove in interface Queue<E>
  - element
```
public E element()
```
    Specified by:
    
    element in interface Queue<E>
  - contains
```
public boolean contains(Object o)
```
    Specified by:
    
    contains in interface Collection<E>
  - iterator
```
public Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface Iterable<E>
    
    Specified by:
    
    iterator in interface Collection<E>
  - toArray
```
public Object[] toArray()
```
    Specified by:
    
    toArray in interface Collection<E>
  - toArray
```
public <T> T[] toArray(T[] a)
```
    Specified by:
    
    toArray in interface Collection<E>
  - remove
```
public boolean remove(Object o)
```
    Specified by:
    
    remove in interface Collection<E>
  - containsAll
```
public boolean containsAll(Collection<?> c)
```
    Specified by:
    
    containsAll in interface Collection<E>
  - addAll
```
public boolean addAll(Collection<? extends E> c)
```
    Specified by:
    
    addAll in interface Collection<E>
  - removeAll
```
public boolean removeAll(Collection<?> c)
```
    Specified by:
    
    removeAll in interface Collection<E>
  - retainAll
```
public boolean retainAll(Collection<?> c)
```
    Specified by:
    
    retainAll in interface Collection<E>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Collection<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<E>
  - size
```
public int size()
```
    Description copied from interface: Pipe
    
    The number of items currently in the container.
    
    Specified by:
    
    size in interface Collection<E>
    
    Specified by:
    
    size in interface Pipe<E>
    
    Returns:
    
    number of items currently in the container.
  - sequenceToBufferOffset
```
public static long sequenceToBufferOffset(long sequence,
                                          long mask)
```

Class AbstractConcurrentArrayQueue<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Queue

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods inherited from interface org.agrona.concurrent.Pipe

Field Detail

TAIL_OFFSET

SHARED_HEAD_CACHE_OFFSET

HEAD_OFFSET

BUFFER_ARRAY_BASE

SHIFT_FOR_SCALE

capacity

buffer

head

tail

headCache

sharedHeadCache

Constructor Detail

AbstractConcurrentArrayQueue

Method Detail

addedCount

removedCount

capacity

remainingCapacity

peek

add

remove

element

contains

iterator

toArray

toArray

remove

containsAll

addAll

removeAll

retainAll

clear

isEmpty

size

sequenceToBufferOffset