org.jgroups.util

Class RingBuffer<T>

java.lang.Object

org.jgroups.util.RingBuffer<T>

public class RingBuffer<T>
extends java.lang.Object

Ring buffer of fixed capacity designed for multiple writers but only a single reader. Advancing the read or write index blocks until it is possible to do so.

Since:

4.0

Author:

Bela Ban

Field Summary

Fields

Modifier and Type	Field and Description
protected T[]	buf
protected int	count
protected java.util.concurrent.locks.Lock	lock
protected java.util.concurrent.locks.Condition	not_empty
protected java.util.concurrent.locks.Condition	not_full
protected int	ri
protected int	wi

Constructor Summary

Constructors

Constructor and Description
RingBuffer(java.lang.Class<T> element_type, int capacity)

Method Summary

Modifier and Type	Method and Description
T[]	buf()
int	capacity()
RingBuffer<T>	clear()
int	count()
int	countLockLockless()
boolean	isEmpty()
RingBuffer<T>	publishReadIndex(int num_elements_read)
RingBuffer<T>	put(T element) Tries to add a new element at the current write index and advances the write index.
int	readIndex()
int	readIndexLockless()
protected int	realIndex(int index) Apparently much more efficient than mod (%)
int	size()
T	take()
java.lang.String	toString()
int	waitForMessages() Blocks until messages are available
int	waitForMessages(int num_spins, BiConsumer<java.lang.Integer,java.lang.Integer> wait_strategy) Blocks until messages are available
int	writeIndex()

Methods inherited from class java.lang.Object

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

Field Detail

buf

protected final T[] buf

ri

protected int ri

wi

protected int wi

count

protected int count

lock

protected final java.util.concurrent.locks.Lock lock

not_empty

protected final java.util.concurrent.locks.Condition not_empty

not_full

protected final java.util.concurrent.locks.Condition not_full

Constructor Detail

RingBuffer

public RingBuffer(java.lang.Class<T> element_type,
                  int capacity)

Method Detail

buf

public T[] buf()

capacity

public int capacity()

readIndexLockless

public int readIndexLockless()

countLockLockless

public int countLockLockless()

readIndex

public int readIndex()

writeIndex

public int writeIndex()

count

public int count()

put

public RingBuffer<T> put(T element)
                  throws java.lang.InterruptedException

Tries to add a new element at the current write index and advances the write index. If the write index is at the same position as the read index, this will block until the read index is advanced.

Parameters:

element - the element to be added. Must not be null, or else this operation returns immediately without adding the null element

Throws:

java.lang.InterruptedException

take

public T take()
       throws java.lang.InterruptedException

Throws:

java.lang.InterruptedException

publishReadIndex

public RingBuffer<T> publishReadIndex(int num_elements_read)

waitForMessages

public int waitForMessages()
                    throws java.lang.InterruptedException

Blocks until messages are available

Throws:

java.lang.InterruptedException

waitForMessages

public int waitForMessages(int num_spins,
                           BiConsumer<java.lang.Integer,java.lang.Integer> wait_strategy)
                    throws java.lang.InterruptedException

Blocks until messages are available

Parameters:

num_spins - the number of times we should spin before acquiring a lock

wait_strategy - the strategy used to spin. The first parameter is the iteration count and the second parameter is the max number of spins

Throws:

java.lang.InterruptedException

clear

public RingBuffer<T> clear()

size

public int size()

isEmpty

public boolean isEmpty()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

realIndex

protected int realIndex(int index)

Apparently much more efficient than mod (%)