OneToOneConcurrentArrayQueue (Hazelcast Root 3.11 API)

java.lang.Object
- com.hazelcast.internal.util.concurrent.OneToOneConcurrentArrayQueue<E>

Type Parameters:

E - type of the elements stored in the queue.

All Implemented Interfaces:

Pipe<E>, QueuedPipe<E>, Iterable<E>, Collection<E>, Queue<E>
```
public class OneToOneConcurrentArrayQueue<E>
extends Object
```
Single producer to single consumer concurrent queue backed by an array. Adapted from the Agrona project.

Field Summary

Fields
Modifier and Type	Field and Description
`protected AtomicReferenceArray<E>`	`buffer`
`protected int`	`capacity`
`protected long`	`head`
`protected static AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueConsumer>`	`HEAD`
`protected long`	`headCache`
`protected long`	`p1`
`protected long`	`p10`
`protected long`	`p11`
`protected long`	`p12`
`protected long`	`p13`
`protected long`	`p14`
`protected long`	`p15`
`protected long`	`p16`
`protected long`	`p17`
`protected long`	`p18`
`protected long`	`p19`
`protected long`	`p2`
`protected long`	`p20`
`protected long`	`p21`
`protected long`	`p22`
`protected long`	`p23`
`protected long`	`p24`
`protected long`	`p25`
`protected long`	`p26`
`protected long`	`p27`
`protected long`	`p28`
`protected long`	`p29`
`protected long`	`p3`
`protected long`	`p30`
`protected long`	`p31`
`protected long`	`p32`
`protected long`	`p33`
`protected long`	`p34`
`protected long`	`p35`
`protected long`	`p36`
`protected long`	`p37`
`protected long`	`p38`
`protected long`	`p39`
`protected long`	`p4`
`protected long`	`p40`
`protected long`	`p41`
`protected long`	`p42`
`protected long`	`p43`
`protected long`	`p44`
`protected long`	`p45`
`protected long`	`p5`
`protected long`	`p6`
`protected long`	`p7`
`protected long`	`p8`
`protected long`	`p9`
`protected static AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueProducer>`	`SHARED_HEAD_CACHE`
`protected long`	`sharedHeadCache`
`protected long`	`tail`
`protected static AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueProducer>`	`TAIL`

Constructor Summary

Constructors
Constructor and Description

OneToOneConcurrentArrayQueue(int requestedCapacity)

Constructors
Constructor and Description
`OneToOneConcurrentArrayQueue(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()` Returns the number of items added to this pipe since creation.
`int`	`capacity()` Returns the number of items this pipe can hold at a time.
`void`	`clear()`
`boolean`	`contains(Object o)`
`boolean`	`containsAll(Collection<?> c)`
`int`	`drain(Predicate<? super E> itemHandler)` Drains the items available in the pipe to the supplied item handler.
`int`	`drainTo(Collection<? super E> target, int limit)` Drains at most `limit` available items into the provided `Collection`.
`E`	`element()`
`boolean`	`isEmpty()`
`Iterator<E>`	`iterator()`
`boolean`	`offer(E e)`
`E`	`peek()`
`E`	`poll()`
`int`	`remainingCapacity()` Returns the number of items this pipe has still room for.
`E`	`remove()`
`boolean`	`remove(Object o)`
`boolean`	`removeAll(Collection<?> c)`
`long`	`removedCount()` Returns the number of items removed from this pipe since creation.
`boolean`	`retainAll(Collection<?> c)`
`protected static int`	`seqToArrayIndex(long sequence, long mask)`
`int`	`size()`
`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.Collection
equals, hashCode, parallelStream, removeIf, spliterator, stream

Methods inherited from interface java.lang.Iterable
forEach

- Field Detail
  - capacity
```
protected final int capacity
```
  - buffer
```
protected final AtomicReferenceArray<E> buffer
```
  - p31
```
protected long p31
```
  - p32
```
protected long p32
```
  - p33
```
protected long p33
```
  - p34
```
protected long p34
```
  - p35
```
protected long p35
```
  - p36
```
protected long p36
```
  - p37
```
protected long p37
```
  - p38
```
protected long p38
```
  - p39
```
protected long p39
```
  - p40
```
protected long p40
```
  - p41
```
protected long p41
```
  - p42
```
protected long p42
```
  - p43
```
protected long p43
```
  - p44
```
protected long p44
```
  - p45
```
protected long p45
```
  - HEAD
```
protected static final AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueConsumer> HEAD
```
  - head
```
protected volatile long head
```
  - p16
```
protected long p16
```
  - p17
```
protected long p17
```
  - p18
```
protected long p18
```
  - p19
```
protected long p19
```
  - p20
```
protected long p20
```
  - p21
```
protected long p21
```
  - p22
```
protected long p22
```
  - p23
```
protected long p23
```
  - p24
```
protected long p24
```
  - p25
```
protected long p25
```
  - p26
```
protected long p26
```
  - p27
```
protected long p27
```
  - p28
```
protected long p28
```
  - p29
```
protected long p29
```
  - p30
```
protected long p30
```
  - TAIL
```
protected static final AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueProducer> TAIL
```
  - SHARED_HEAD_CACHE
```
protected static final AtomicLongFieldUpdater<com.hazelcast.internal.util.concurrent.AbstractConcurrentArrayQueueProducer> SHARED_HEAD_CACHE
```
  - tail
```
protected volatile long tail
```
  - headCache
```
protected long headCache
```
  - sharedHeadCache
```
protected volatile long sharedHeadCache
```
  - p1
```
protected long p1
```
  - p2
```
protected long p2
```
  - p3
```
protected long p3
```
  - p4
```
protected long p4
```
  - p5
```
protected long p5
```
  - p6
```
protected long p6
```
  - p7
```
protected long p7
```
  - p8
```
protected long p8
```
  - p9
```
protected long p9
```
  - p10
```
protected long p10
```
  - p11
```
protected long p11
```
  - p12
```
protected long p12
```
  - p13
```
protected long p13
```
  - p14
```
protected long p14
```
  - p15
```
protected long p15
```
- Constructor Detail
  - OneToOneConcurrentArrayQueue
```
public OneToOneConcurrentArrayQueue(int requestedCapacity)
```
- Method Detail
  - offer
```
public boolean offer(E e)
```
  - poll
```
public E poll()
```
  - drain
```
public int drain(Predicate<? super E> itemHandler)
```
    Description copied from interface: Pipe
    
    Drains the items available in the pipe to the supplied item handler. The handler returns a boolean which decides whether to continue draining. If it returns false, this method refrains from draining further items and returns.
    Implementation note: this method is expected to take advantage of the fact that many items are being drained at once and minimize the per-item cost of housekeeping.
    
    Parameters:
    
    itemHandler - the item handler
    
    Returns:
    
    the number of drained items
  - drainTo
```
public int drainTo(Collection<? super E> target,
                   int limit)
```
    Description copied from interface: Pipe
    
    Drains at most limit available items into the provided Collection.
    Implementation note: this method is expected to take advantage of the fact that many items are being drained at once and minimize the per-item cost of housekeeping.
    
    Parameters:
    
    target - destination for the drained items
    
    limit - the maximum number of items to drain
    
    Returns:
    
    the number of drained items
  - addedCount
```
public long addedCount()
```
    Description copied from interface: Pipe
    
    Returns the number of items added to this pipe since creation.
    
    Specified by:
    
    addedCount in interface Pipe<E>
  - removedCount
```
public long removedCount()
```
    Description copied from interface: Pipe
    
    Returns the number of items removed from this pipe since creation.
    
    Specified by:
    
    removedCount in interface Pipe<E>
  - capacity
```
public int capacity()
```
    Description copied from interface: Pipe
    
    Returns the number of items this pipe can hold at a time.
    
    Specified by:
    
    capacity in interface Pipe<E>
  - remainingCapacity
```
public int remainingCapacity()
```
    Description copied from interface: Pipe
    
    Returns the number of items this pipe has still room for.
    
    Specified by:
    
    remainingCapacity in interface Pipe<E>
  - 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>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Collection<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>
  - size
```
public int size()
```
    Specified by:
    
    size in interface Collection<E>
  - seqToArrayIndex
```
protected static int seqToArrayIndex(long sequence,
                                     long mask)
```

Class OneToOneConcurrentArrayQueue<E>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Field Detail

capacity

buffer

p31

p32

p33

p34

p35

p36

p37

p38

p39

p40

p41

p42

p43

p44

p45

HEAD

head

p16

p17

p18

p19

p20

p21

p22

p23

p24

p25

p26

p27

p28

p29

p30

TAIL

SHARED_HEAD_CACHE

tail

headCache

sharedHeadCache

p1

p2

p3

p4

p5

p6

p7

p8

p9

p10

p11

p12

p13

p14

p15

Constructor Detail

OneToOneConcurrentArrayQueue

Method Detail

offer

poll

drain

drainTo

addedCount

removedCount

capacity

remainingCapacity

peek

add

remove

element

isEmpty

contains

iterator