LMAX Disruptor

https://lmax-exchange.github.io/disruptor
Admin
LMAX Disruptor is a high-performance, lock-free inter-thread messaging library and concurrency...
Tokens:130,592
Snippets:1,594
Trust Score:8.3
Update:2 months ago
Show doc for...
Tokens:
Raw
### Disruptor Setup and Event Publishing

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/package-summary.html

Demonstrates the basic setup of a Disruptor, including specifying buffer size, constructing the Disruptor with an event factory and thread factory, connecting an event handler, starting the Disruptor, and publishing events to the ring buffer. Ensure the buffer size is a power of 2. The example includes a loop for continuous event publishing with a delay.

```java
 // Specify the size of the ring buffer, must be power of 2.
  int bufferSize = 1024;

  // Construct the Disruptor
  Disruptor<LongEvent> disruptor = new Disruptor<>(LongEvent::new, bufferSize, DaemonThreadFactory.INSTANCE);

  // Connect the handler
  disruptor.handleEventsWith((event, sequence, endOfBatch) -> System.out.println("Event: " + event));

  // Start the Disruptor, starts all threads running
  disruptor.start();

  // Get the ring buffer from the Disruptor to be used for publishing.
  RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();

  ByteBuffer bb = ByteBuffer.allocate(8);
  for (long l = 0; true; l++)
  {
      bb.putLong(0, l);
      ringBuffer.publishEvent((event, sequence, buffer) -> event.set(buffer.getLong(0)), bb);
      Thread.sleep(1000);
  }
 
```

--------------------------------

### Disruptor Setup and Usage Example

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/package-summary.html

Demonstrates the setup of a RingBuffer with a single-threaded claim strategy and sleeping wait strategy, event handling, and publishing events. Ensure EXECUTOR is properly initialized.

```java
 // Event holder for data to be exchanged
 public final class ValueEvent
 {
     private long value;

     public long getValue()
     {
         return value;
     }

     public void setValue(final long value)
     {
         this.value = value;
     }

     public final static EventFactory<ValueEvent> EVENT_FACTORY = new EventFactory<ValueEvent>()
     {
         public ValueEvent newInstance()
         {
             return new ValueEvent();
         }
     };
 }

 // Callback handler which can be implemented by EventProcessors
 final EventHandler<ValueEvent> eventHandler = new EventHandler<ValueEvent>()
 {
     public void onEvent(final ValueEvent event, final long sequence, final boolean endOfBatch)
         throws Exception
     {
         // process a new event as it becomes available.
     }
 };

 RingBuffer<ValueEvent> ringBuffer =
     new RingBuffer<ValueEvent>(ValueEvent.EVENT_FACTORY,
                                new SingleThreadedClaimStrategy(BUFFER_SIZE),
                                new SleepingWaitStrategy());

 SequenceBarrier<ValueEvent> sequenceBarrier = ringBuffer.newBarrier();
 BatchEventProcessor<ValueEvent> batchProcessor = new BatchEventProcessor<ValueEvent>(sequenceBarrier, eventHandler);
 ringBuffer.setGatingSequences(batchProcessor.getSequence());

 // Each processor runs on a separate thread
 EXECUTOR.submit(batchProcessor);

 // Publishers claim events in sequence
 long sequence = ringBuffer.next();
 ValueEvent event = ringBuffer.get(sequence);

 event.setValue(1234);

 // publish the event so it is available to EventProcessors
 ringBuffer.publish(sequence);
 
```

--------------------------------

### onStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RewindableEventHandler.html

Called once on thread start before the first event is available. Useful for initial setup.

```java
default void onStart()
```

--------------------------------

### Basic Disruptor Setup

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Demonstrates how to initialize a Disruptor with a factory, buffer size, and thread pool, and then chain event handlers. This setup is useful for sequential processing of events by multiple handlers.

```java
Disruptor<MyEvent> disruptor = new Disruptor<MyEvent>(MyEvent.FACTORY, 32, Executors.newCachedThreadPool());
 EventHandler<MyEvent> handler1 = new EventHandler<MyEvent>() { ... };
 EventHandler<MyEvent> handler2 = new EventHandler<MyEvent>() { ... };
 disruptor.handleEventsWith(handler1);
 disruptor.after(handler1).handleEventsWith(handler2);

 RingBuffer ringBuffer = disruptor.start();
 
```

--------------------------------

### onStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/AggregateEventHandler.html

Called when the EventHandler is starting.

```APIDOC
## onStart()

### Description
Called when the EventHandler is starting.
```

--------------------------------

### Handle Events with Event Processors

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up custom event processors directly. The Disruptor automatically starts these processors when start() is called. This method can initiate a processing chain and is typically called once during setup.

```java
public	EventHandlerGroup<T>	handleEventsWith	(EventProcessor... processors)
```

--------------------------------

### onStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RewindableEventHandler.html

Called once on thread start before the first event is available.

```APIDOC
## onStart Method

### Description
Called once on thread start before the first event is available.

### Signature
```java
default void onStart()
```
```

--------------------------------

### handleEventsWith(EventProcessor... processors)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up custom event processors to handle events from the ring buffer. These processors will be started when `start()` is called and can form the beginning of an event processing chain.

```APIDOC
## handleEventsWith(EventProcessor... processors)

### Description
Sets up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when `start()` is called. This method can be used as the start of a chain.

### Parameters
* `processors` (EventProcessor...) - The event processors that will process events.

### Returns
A `EventHandlerGroup` that can be used to chain dependencies.
```

--------------------------------

### Handle Events with Event Processor Factories

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up custom event processors using factories. The Disruptor will start these processors upon calling start(). This method can begin a processing chain and is usually called once during setup.

```java
@SafeVarargs
public final	EventHandlerGroup<T>	handleEventsWith	(EventProcessorFactory<T>... eventProcessorFactories)
```

--------------------------------

### onStart

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventHandler.html

Called once on thread start before the first event is available.

```APIDOC
## onStart

### Description
Called once on thread start before first event is available.

### Method Signature
```java
default void onStart()
```
```

--------------------------------

### onStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/AggregateEventHandler.html

Lifecycle method invoked when the event processor starts.

```java
public void onStart()
```

--------------------------------

### handleEventsWith(EventProcessorFactory... eventProcessorFactories)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up custom event processors using factories to handle events from the ring buffer. These processors will be started when `start()` is called and can form the beginning of an event processing chain.

```APIDOC
## handleEventsWith(EventProcessorFactory... eventProcessorFactories)

### Description
Sets up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when `start()` is called. This method can be used as the start of a chain. This call is additive, but generally should only be called once when setting up the Disruptor instance.

### Parameters
* `eventProcessorFactories` (EventProcessorFactory<T>...) - The event processor factories to use to create the event processors that will process events.

### Returns
A `EventHandlerGroup` that can be used to chain dependencies.
```

--------------------------------

### start

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Starts the event processors and returns the fully configured ring buffer. The ring buffer is set up to prevent overwriting any entry that is yet to be processed by the slowest event processor. This method must only be called once after all event processors have been added.

```APIDOC
## start

### Description
Starts the event processors and returns the fully configured ring buffer. The ring buffer is set up to prevent overwriting any entry that is yet to be processed by the slowest event processor. This method must only be called once after all event processors have been added.

### Returns
The configured ring buffer.

### Method Signature
```java
public RingBuffer<T> start()
```
```

--------------------------------

### onStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventHandler.html

Called once when the event processing thread starts, before any events are available.

```java
default void onStart();
```

--------------------------------

### translateTo Method Implementation Example

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventTranslatorVararg.html

An example of how the translateTo method is implemented to translate variable arguments into an event.

```java
void translateTo(T event,
                 long sequence,
                 java.lang.Object... args)
```

--------------------------------

### Disruptor.start()

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Starts the event processors and returns the fully configured ring buffer. This is a crucial step to begin processing events.

```APIDOC
## start()

### Description
Starts the event processors and returns the fully configured ring buffer.

### Method
`public final RingBuffer<T> start()`

### Endpoint
N/A (Java Method Call)

### Parameters
None

### Response
- **RingBuffer<T>** - The fully configured ring buffer.
```

--------------------------------

### Configuring and Running Disruptor with DSL

Source: https://lmax-exchange.github.io/disruptor/user-guide/index.html

This example demonstrates setting up the Disruptor using the DSL, handling events, and publishing data in a loop. Ensure proper exception handling for `Thread.sleep`.

```java
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.examples.longevent.LongEvent;
import com.lmax.disruptor.examples.longevent.LongEventFactory;
import com.lmax.disruptor.examples.longevent.LongEventHandler;
import com.lmax.disruptor.util.DaemonThreadFactory;

import java.nio.ByteBuffer;

public class LongEventMain
{
    public static void main(String[] args) throws Exception
    {
        LongEventFactory factory = new LongEventFactory();

        int bufferSize = 1024;
        Disruptor<LongEvent> disruptor =
                new Disruptor<>(factory, bufferSize, DaemonThreadFactory.INSTANCE);
        disruptor.handleEventsWith(new LongEventHandler());
        disruptor.start();

        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
        LongEventProducer producer = new LongEventProducer(ringBuffer);
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long l = 0; true; l++)
        {
            bb.putLong(0, l);
            producer.onData(bb);
            Thread.sleep(1000);
        }
    }
}
```

--------------------------------

### hasStarted

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Checks if disruptor has been started.

```APIDOC
## hasStarted

### Description
Checks if disruptor has been started.

### Method
public boolean hasStarted()

### Returns
true when start has been called on this instance; otherwise false
```

--------------------------------

### Handle Events with EventProcessorFactories

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/EventHandlerGroup.html

Sets up custom event processors using provided factories to handle events from the ring buffer. These processors will be automatically started when the Disruptor starts. This is useful for chaining dependencies.

```java
@SafeVarargs
public final EventHandlerGroup<T> then(EventProcessorFactory<T>... eventProcessorFactories)
```

--------------------------------

### Disruptor.hasStarted()

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Checks if the Disruptor has been started and is ready to process events.

```APIDOC
## Disruptor.hasStarted()

### Description
Checks if disruptor has been started.

### Method
`public boolean hasStarted()`
```

--------------------------------

### Batch Event Producing Example

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequenced.html

Demonstrates how to claim and publish a batch of events using the `next(n)` and `publish(lo, hi)` methods. It involves calculating the sequence range and iterating to fill events.

```java
intn=10;
 longhi=sequencer.next(n);
 longlo=hi-(n-1);
 for(longsequence=lo;sequence<=hi;sequence++) {
     // Do work.
 }
 sequencer.publish(lo,hi);
 
```

--------------------------------

### Start Disruptor and Get Ring Buffer

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Starts the event processors and returns the fully configured ring buffer. This method ensures the ring buffer is set up to prevent overwriting unprocessed entries and must be called only once after all processors are added.

```java
public RingBuffer<T> start()
```

--------------------------------

### Publish Events with Method References

Source: https://lmax-exchange.github.io/disruptor/user-guide/index.html

Shows how to publish events using method references, which can be a more concise alternative to lambdas. This example utilizes static methods for event handling and translation.

```java
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.examples.longevent.LongEvent;
import com.lmax.disruptor.util.DaemonThreadFactory;

import java.nio.ByteBuffer;

public class LongEventMain
{
    public static void handleEvent(LongEvent event, long sequence, boolean endOfBatch)
    {
        System.out.println(event);
    }

    public static void translate(LongEvent event, long sequence, ByteBuffer buffer)
    {
        event.set(buffer.getLong(0));
    }

    public static void main(String[] args) throws Exception
    {
        int bufferSize = 1024;

        Disruptor<LongEvent> disruptor =
                new Disruptor<>(LongEvent::new, bufferSize, DaemonThreadFactory.INSTANCE);
        disruptor.handleEventsWith(LongEventMain::handleEvent);
        disruptor.start();

        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long l = 0; true; l++)
        {
            bb.putLong(0, l);
            ringBuffer.publishEvent(LongEventMain::translate, bb);
            Thread.sleep(1000);
        }
    }
}
```

--------------------------------

### Try Publish Events with Batch Information

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempts to publish events with variable user-supplied arguments, specifying batch start and size. Returns false if there is insufficient capacity.

```java
public boolean tryPublishEvents
(EventTranslatorVararg<E> translator,
 int batchStartsAt,
 int batchSize,
 java.lang.Object[]... args)
```

--------------------------------

### Implement EarlyReleaseHandler for Large Batches

Source: https://lmax-exchange.github.io/disruptor/user-guide/index.html

An example handler that demonstrates 'Early Release' for large batches. It allows for releasing the sequence number before the entire batch is processed, based on logical chunks of work.

```java
public class EarlyReleaseHandler implements EventHandler<LongEvent>
{
    private Sequence sequenceCallback;
    private int batchRemaining = 20;

    @Override
    public void setSequenceCallback(final Sequence sequenceCallback)
    {
        this.sequenceCallback = sequenceCallback;
    }

    @Override
    public void onEvent(final LongEvent event, final long sequence, final boolean endOfBatch)
    {
        processEvent(event);

        boolean logicalChunkOfWorkComplete = isLogicalChunkOfWorkComplete();
        if (logicalChunkOfWorkComplete)
        {
            sequenceCallback.set(sequence);
        }

        batchRemaining = logicalChunkOfWorkComplete || endOfBatch ? 20 : batchRemaining;
    }

    private boolean isLogicalChunkOfWorkComplete()
    {
        // Ret true or false based on whatever criteria is required for the smaller
        // chunk.  If this is doing I/O, it may be after flushing/syncing to disk
        // or at the end of DB batch+commit.
        // Or it could simply be working off a smaller batch size.

        return --batchRemaining == -1;
    }

    private void processEvent(final LongEvent event)
    {
        // Do processing
    }
}
```

--------------------------------

### Handle On Start Exception

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/ExceptionHandler.html

Callback to notify of an exception during the event handler's onStart() method. This method is invoked when an error occurs during the initialization phase of an event handler.

```java
void handleOnStartException(java.lang.Throwable ex)
```

--------------------------------

### BusySpinWaitStrategy Constructor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/BusySpinWaitStrategy.html

Initializes a new instance of the BusySpinWaitStrategy. No specific setup is required beyond instantiation.

```java
public BusySpinWaitStrategy()
```

--------------------------------

### Handle On Start Exception

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/FatalExceptionHandler.html

Callback to notify of an exception during the onStart() phase of an event handler. This method is invoked if an error occurs when an EventHandler is being initialized.

```java
public void handleOnStartException(Throwable ex)
```

--------------------------------

### Sequence Constructor - With Initial Value

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequence.html

Initializes a new Sequence with a specified starting value. Useful for setting a specific initial state.

```java
public Sequence(long initialValue)

```

--------------------------------

### onBatchStart Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RewindableEventHandler.html

Invoked by BatchEventProcessor before processing a batch of events. Useful for pre-processing or setup related to a batch.

```java
default void onBatchStart(long batchSize,
                          long queueDepth)
```

--------------------------------

### Single Producer/Consumer with BatchHandler

Source: https://lmax-exchange.github.io/disruptor/disruptor.html

Example of a single producer and single consumer using the BatchHandler interface. The consumer runs on a separate thread, processing entries as they become available. Ensure EXECUTOR is properly initialized.

```java
// Callback handler which can be implemented by consumers
final BatchHandler<ValueEntry> batchHandler = new BatchHandler<ValueEntry>()
{
public void onAvailable(final ValueEntry entry) throws Exception
{
// process a new entry as it becomes available.
}

    public void onEndOfBatch() throws Exception
    {
        // useful for flushing results to an IO device if necessary.
    }

    public void onCompletion()
    {
        // do any necessary clean up before shutdown
    }
};

RingBuffer<ValueEntry> ringBuffer =
    new RingBuffer<ValueEntry>(ValueEntry.ENTRY_FACTORY, SIZE, 
                               ClaimStrategy.Option.SINGLE_THREADED,
                               WaitStrategy.Option.YIELDING);
ConsumerBarrier<ValueEntry> consumerBarrier = ringBuffer.createConsumerBarrier();
BatchConsumer<ValueEntry> batchConsumer =
    new BatchConsumer<ValueEntry>(consumerBarrier, batchHandler);
ProducerBarrier<ValueEntry> producerBarrier = ringBuffer.createProducerBarrier(batchConsumer);

// Each consumer can run on a separate thread
EXECUTOR.submit(batchConsumer);

// Producers claim entries in sequence
ValueEntry entry = producerBarrier.nextEntry();

// copy data into the entry container

// make the entry available to consumers
producerBarrier.commit(entry);
```

--------------------------------

### Try Publish Events with Three Arguments and Batch Control

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempts to publish a batch of events using a translator that accepts three arguments. Returns false if there is insufficient capacity. Allows specifying batch start and size.

```java
public	<A,B,C> boolean tryPublishEvents(EventTranslatorThreeArg<E,A,B,C> translator,
                                                    int	batchStartsAt,
                                                    int	batchSize,
                                                    A[]	arg0,
                                                    B[]	arg1,
                                                    C[]	arg2)
```

--------------------------------

### Handling Events with EventProcessorFactories

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/EventHandlerGroup.html

Sets up custom event processors using factories to handle events from the ring buffer. The Disruptor will automatically start these processors when Disruptor.start() is called.

```APIDOC
## handleEventsWith(EventProcessorFactory<T>... eventProcessorFactories)

### Description
Set up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when `Disruptor.start()` is called.

### Method
`EventHandlerGroup<T> handleEventsWith(EventProcessorFactory<T>... eventProcessorFactories)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **EventHandlerGroup<T>** - An EventHandlerGroup that can be used to set up a event processor barrier over the created event processors.

#### Response Example
None
```

--------------------------------

### tryPublishEvents with two arguments and batch details

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventSink.html

Attempts to publish events with two user-supplied arguments per event, specifying batch start and size. Returns true if successful, false if there is insufficient capacity.

```APIDOC
## tryPublishEvents<A, B> (EventTranslatorTwoArg<E, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)

### Description
Allows two user supplied arguments per event.

### Method
```java
<A, B> boolean tryPublishEvents(EventTranslatorTwoArg<E, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
```

### Parameters
* `translator` (EventTranslatorTwoArg<E, A, B>) - The user specified translation for the event
* `batchStartsAt` (int) - The first element of the array which is within the batch.
* `batchSize` (int) - The actual size of the batch.
* `arg0` (A[]) - An array of user supplied arguments, one element per event.
* `arg1` (B[]) - An array of user supplied arguments, one element per event.
```

--------------------------------

### Handle Events with Rewindable Handlers

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up rewindable event handlers with a custom batch rewind strategy. These handlers process events in parallel. This method can start a processing chain and is typically called once during setup.

```java
@SafeVarargs
public final	EventHandlerGroup<T>	handleEventsWith	(BatchRewindStrategy	batchRewindStrategy,
                                                   RewindableEventHandler<? super T>... handlers)
```

--------------------------------

### Build and Upload with Gradle

Source: https://lmax-exchange.github.io/disruptor/developer-guide/index.html

Builds the project and uploads artifacts to Sonatype. Ensure the signing configuration is correctly set up in `gradle.properties`.

```bash
./gradlew publish
```

--------------------------------

### get(long sequence)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Get the event for a given sequence in the RingBuffer.

```APIDOC
## get(long sequence)

### Description
Get the event for a given sequence in the RingBuffer.

### Method
public T get(long sequence)

### Parameters
#### Path Parameters
- **sequence** (long) - for the event.

### Returns
event for the sequence.

### See Also
`RingBuffer.get(long)`
```

--------------------------------

### tryPublishEvents with Three Arguments and Batching

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempts to publish a batch of events with three user-supplied arguments per event, specifying the start and size of the batch. Returns true if the events were published successfully, and false if there was insufficient capacity.

```APIDOC
## tryPublishEvents

### Description
Allows three user supplied arguments per event.

### Method Signature
```java
public <A,B,C> boolean tryPublishEvents(EventTranslatorThreeArg<E,A,B,C> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1, C[] arg2)
```

### Parameters
* `translator` - The user specified translation for the event.
* `batchStartsAt` - The first element of the array which is within the batch.
* `batchSize` - The actual size of the batch.
* `arg0` - An array of user supplied arguments, one element per event.
* `arg1` - An array of user supplied arguments, one element per event.
* `arg2` - An array of user supplied arguments, one element per event.

### Returns
`true` if the value was published, `false` if there was insufficient capacity.
```

--------------------------------

### handleEventsWith(EventProcessorFactory<T>... eventProcessorFactories)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/EventHandlerGroup.html

Sets up custom event processors using provided factories to handle events from the ring buffer. The Disruptor automatically starts these processors when `Disruptor.start()` is called. This method is useful for creating complex event processing chains with custom processor logic.

```APIDOC
## handleEventsWith(EventProcessorFactory<T>... eventProcessorFactories)

### Description
Set up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when `Disruptor.start()` is called.
This method is generally used as part of a chain. For example if `A` must process events before `B`:
```
dw.after(A).handleEventsWith(B);
```

### Parameters
* `eventProcessorFactories` - the event processor factories to use to create the event processors that will process events.

### Returns
a `EventHandlerGroup` that can be used to chain dependencies.
```

--------------------------------

### handleEventsWith(EventHandler... handlers)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up event handlers to process events from the ring buffer in parallel as they become available. This can be used as the start of an event processing chain.

```APIDOC
## handleEventsWith(EventHandler... handlers)

### Description
Sets up event handlers to handle events from the ring buffer. These handlers will process events as soon as they become available, in parallel. This method can be used as the start of a chain. This call is additive, but generally should only be called once when setting up the Disruptor instance.

### Parameters
* `handlers` (EventHandler<? super T>...) - The event handlers that will process events.

### Returns
A `EventHandlerGroup` that can be used to chain dependencies.
```

--------------------------------

### Handle Events with Custom Event Processors

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/EventHandlerGroup.html

Sets up custom event processors using factories to handle events from the ring buffer. These processors will be automatically started when `Disruptor.start()` is called. This method is ideal for chaining dependencies, for instance, `dw.after(A).handleEventsWith(B)`.

```java
@SafeVarargs
public final EventHandlerGroup<T> handleEventsWith(EventProcessorFactory<T>... eventProcessorFactories)
```

--------------------------------

### tryPublishEvents with one argument and batch details

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventSink.html

Attempts to publish events with a single user-supplied argument, specifying batch start and size. Returns true if successful, false if there is insufficient capacity.

```APIDOC
## tryPublishEvents<A> (EventTranslatorOneArg<E, A> translator, int batchStartsAt, int batchSize, A[] arg0)

### Description
Allows one user supplied argument.

### Method
```java
<A> boolean tryPublishEvents(EventTranslatorOneArg<E, A> translator, int batchStartsAt, int batchSize, A[] arg0)
```

### Parameters
* `translator` (EventTranslatorOneArg<E, A>) - The user specified translation for each event
* `batchStartsAt` (int) - The first element of the array which is within the batch.
* `batchSize` (int) - The actual size of the batch
* `arg0` (A[]) - An array of user supplied arguments, one element per event.
```

--------------------------------

### Get remaining capacity

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/MultiProducerSequencer.html

Get the remaining capacity for this sequencer. This indicates how many more events can be published before the buffer is full.

```java
public long remainingCapacity()
```

--------------------------------

### SequenceGroup.get() - Get Minimum Sequence

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/SequenceGroup.html

Retrieves the minimum sequence value across all sequences in the group. This method overrides the get() method from the base Sequence class.

```java
public long get()
```

--------------------------------

### Run JMH Benchmarks with Specific CPU Pinning

Source: https://lmax-exchange.github.io/disruptor/developer-guide/index.html

Execute JMH benchmarks on a machine with isolated CPUs, pinning Java threads and JMH benchmark threads to specific cores using taskset and a shell script. This example runs the MultiProducersSequencerBenchmark.

```bash
#!/bin/bash
JAVA_HOME=/opt/jdk11/1.11.0.6_zulu11.37.17_ca-1
ISOLATED_CPUS=7,9,11,13,15,17,19,21,23 $JAVA_HOME/bin/java -jar ./disruptor-4.0.0-SNAPSHOT-jmh.jar -rf json -rff /tmp/jmh-result.json -foe true -v NORMAL -prof perf -jvmArgsPrepend -Xmx256m -jvmArgsPrepend -Xms256m -jvmArgsPrepend -XX:MaxDirectMemorySize=1g $@
bench-machine ~ $ sudo cset proc -v --exec app -- taskset -c 5,8,10,12,14,16,18,20,22,29,32,34,36,38,40,42,44,46 ./runBenchmarks.sh MultiProducersSequencerBenchmark
```

--------------------------------

### publishEvents with two arguments and batch details

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventSink.html

Publishes events with two user-supplied arguments per event, specifying batch start and size.

```APIDOC
## publishEvents<A, B> (EventTranslatorTwoArg<E, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)

### Description
Allows two user supplied arguments per event.

### Method
```java
<A, B> void publishEvents(EventTranslatorTwoArg<E, A, B> translator, int batchStartsAt, int batchSize, A[] arg0, B[] arg1)
```

### Parameters
* `translator` (EventTranslatorTwoArg<E, A, B>) - The user specified translation for the event
* `batchStartsAt` (int) - The first element of the array which is within the batch.
* `batchSize` (int) - The actual size of the batch.
* `arg0` (A[]) - An array of user supplied arguments, one element per event.
* `arg1` (B[]) - An array of user supplied arguments, one element per event.
```

--------------------------------

### Chaining with EventProcessorFactories

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/EventHandlerGroup.html

Sets up custom event processors using factories to consume events from the ring buffer. These processors will be started automatically when Disruptor.start() is called and will execute after all processors in the current group.

```APIDOC
## then(EventProcessorFactory<T>... eventProcessorFactories)

### Description
Set up custom event processors to handle events from the ring buffer. The Disruptor will automatically start these processors when `Disruptor.start()` is called. This method is generally used as part of a chain.

### Method
`EventHandlerGroup<T> then(EventProcessorFactory<T>... eventProcessorFactories)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **EventHandlerGroup<T>** - a `EventHandlerGroup` that can be used to set up a event processor barrier over the created event processors.

#### Response Example
None
```

--------------------------------

### RingBuffer Creation with WaitStrategy

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/class-use/WaitStrategy.html

Demonstrates how to create a RingBuffer with a specified WaitStrategy.

```APIDOC
## RingBuffer.create

### Description
Creates a new Ring Buffer with the specified producer type, event factory, buffer size, and wait strategy.

### Method Signature
`static <E> RingBuffer<E> create(ProducerType producerType, EventFactory<E> factory, int bufferSize, WaitStrategy waitStrategy)`

### Parameters
* `producerType` (ProducerType) - The type of producer (SINGLE or MULTI).
* `factory` (EventFactory<E>) - The factory to create events.
* `bufferSize` (int) - The size of the ring buffer.
* `waitStrategy` (WaitStrategy) - The strategy to use for waiting for new data.
```

```APIDOC
## RingBuffer.createMultiProducer

### Description
Creates a new multiple producer RingBuffer with the specified event factory, buffer size, and wait strategy.

### Method Signature
`static <E> RingBuffer<E> createMultiProducer(EventFactory<E> factory, int bufferSize, WaitStrategy waitStrategy)`

### Parameters
* `factory` (EventFactory<E>) - The factory to create events.
* `bufferSize` (int) - The size of the ring buffer.
* `waitStrategy` (WaitStrategy) - The strategy to use for waiting for new data.
```

```APIDOC
## RingBuffer.createSingleProducer

### Description
Creates a new single producer RingBuffer with the specified event factory, buffer size, and wait strategy.

### Method Signature
`static <E> RingBuffer<E> createSingleProducer(EventFactory<E> factory, int bufferSize, WaitStrategy waitStrategy)`

### Parameters
* `factory` (EventFactory<E>) - The factory to create events.
* `bufferSize` (int) - The size of the ring buffer.
* `waitStrategy` (WaitStrategy) - The strategy to use for waiting for new data.
```

--------------------------------

### SimpleBatchRewindStrategy Constructor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/SimpleBatchRewindStrategy.html

Initializes a new instance of the SimpleBatchRewindStrategy class.

```APIDOC
## SimpleBatchRewindStrategy()

### Description
Initializes a new instance of the `SimpleBatchRewindStrategy` class.

### Method
`public SimpleBatchRewindStrategy()`
```

--------------------------------

### handleOnStartException

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/IgnoreExceptionHandler.html

Callback to notify of an exception during the startup process.

```APIDOC
## handleOnStartException(Throwable ex)

### Description
Callback to notify of an exception during `EventHandlerBase.onStart()`.

### Method
```java
public void handleOnStartException(Throwable ex)
```

### Parameters
* **ex** (Throwable) - throw during the starting process.
```

--------------------------------

### Handle Events with Multiple Handlers

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Sets up event handlers to process events in parallel as they become available. This method can initiate a processing chain. It's generally called once during Disruptor setup and is additive.

```java
@SafeVarargs
public final	EventHandlerGroup<T>	handleEventsWith	(EventHandler<? super T>... handlers)
```

--------------------------------

### remainingCapacity

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Gets the remaining capacity of the ring buffer.

```APIDOC
## remainingCapacity()

### Description
Get the remaining capacity for this ringBuffer.

### Method
long

### Returns
- long: The remaining capacity.
```

--------------------------------

### Get highest published sequence

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/MultiProducerSequencer.html

Get the highest sequence number that can be safely read from the ring buffer. This method may scan values to determine the highest available sequence. Consumers should pass a value one higher than the last successfully processed sequence.

```java
public long getHighestPublishedSequence(long lowerBound, long availableSequence)
```

--------------------------------

### getCursor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Get the value of the cursor indicating the published sequence.

```APIDOC
## getCursor

### Description
Get the value of the cursor indicating the published sequence.

### Method
public long getCursor()

### Returns
value of the cursor for events that have been published.
```

--------------------------------

### Disruptor Constructor with WaitStrategy

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/class-use/WaitStrategy.html

Shows how to initialize a Disruptor instance with a specific WaitStrategy.

```APIDOC
## Disruptor Constructor

### Description
Creates a new Disruptor instance with the specified event factory, ring buffer size, thread factory, producer type, and wait strategy.

### Method Signature
`Disruptor(EventFactory<T> eventFactory, int ringBufferSize, ThreadFactory threadFactory, ProducerType producerType, WaitStrategy waitStrategy)`

### Parameters
* `eventFactory` (EventFactory<T>) - The factory to create events.
* `ringBufferSize` (int) - The size of the ring buffer.
* `threadFactory` (ThreadFactory) - The factory to create threads.
* `producerType` (ProducerType) - The type of producer (SINGLE or MULTI).
* `waitStrategy` (WaitStrategy) - The strategy to use for waiting for new data.
```

--------------------------------

### remainingCapacity

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequenced.html

Gets the number of remaining available slots in the sequencer.

```APIDOC
## remainingCapacity

### Description
Get the remaining capacity for this sequencer.

### Method
```java
long remainingCapacity()
```

### Returns
- `long`: The number of slots remaining.
```

--------------------------------

### EventFactory Interface Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Documentation for the `newInstance` method within the `EventFactory` interface.

```APIDOC
## newInstance()

### Description
Implementations should instantiate an event object, with all memory already allocated where possible.

### Interface
com.lmax.disruptor.EventFactory

### Returns
A new event object.
```

--------------------------------

### after

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Create a group of event handlers or processors to be used as a dependency, establishing a barrier for subsequent handlers or processors.

```APIDOC
## after (EventHandlerIdentity...)

### Description
Create a group of event handlers to be used as a dependency. For example, if handler `A` must process events before handler `B`.

### Parameters
* `handlers` - the event handlers, previously set up with `handleEventsWith(EventHandler[])`, that will form the barrier for subsequent handlers or processors.

### Returns
An `EventHandlerGroup` that can be used to set up a dependency barrier over the specified event handlers.

### Example Usage
```java
dw.after(A).handleEventsWith(B);
```

### Method Signature
```java
public final EventHandlerGroup<T> after(EventHandlerIdentity... handlers)
```
```

```APIDOC
## after (EventProcessor...)

### Description
Create a group of event processors to be used as a dependency. This establishes a barrier for subsequent handlers or processors.

### Parameters
* `processors` - the event processors, previously set up with `handleEventsWith(com.lmax.disruptor.EventProcessor...)`, that will form the barrier for subsequent handlers or processors.

### Returns
An `EventHandlerGroup` that can be used to set up a `SequenceBarrier` over the specified event processors.

### See Also
`after(EventHandlerIdentity[])`

### Method Signature
```java
public EventHandlerGroup<T> after(EventProcessor... processors)
```
```

--------------------------------

### handleOnStartException Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/ExceptionHandlerWrapper.html

Callback to notify of an exception during the onStart phase.

```APIDOC
## handleOnStartException(Throwable ex)

### Description
Callback to notify of an exception during `EventHandlerBase.onStart()`.

### Method
`public void handleOnStartException(Throwable ex)`

### Parameters
* **ex** (Throwable) - The exception thrown during the starting process.
```

--------------------------------

### getSequenceValueFor(EventHandlerIdentity handler)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/Disruptor.html

Gets the sequence value for the specified event handlers.

```APIDOC
## getSequenceValueFor(EventHandlerIdentity handler)

### Description
Gets the sequence value for the specified event handlers.

### Method
public long getSequenceValueFor(EventHandlerIdentity handler)

### Parameters
#### Path Parameters
- **handler** (EventHandlerIdentity) - eventHandler to get the sequence for.

### Returns
eventHandler's sequence
```

--------------------------------

### remainingCapacity

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/SingleProducerSequencer.html

Get the remaining capacity for this sequencer. This method is inherited from the Sequenced interface.

```APIDOC
## remainingCapacity

### Description
Get the remaining capacity for this sequencer.

### Returns
- The number of slots remaining.
```

--------------------------------

### tryNext()

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempt to claim the next available sequence. If no space is available, an InsufficientCapacityException is thrown. Always ensure to publish the sequence afterward.

```APIDOC
## tryNext()

### Description
Attempt to claim the next available sequence. If no space is available, an InsufficientCapacityException is thrown. Always ensure to publish the sequence afterward.

### Method
`tryNext()`

### Returns
`long` - The next sequence to publish to.

### Throws
`InsufficientCapacityException` - if the necessary space in the ring buffer is not available

### See Also
`publish(long)`, `get(long)`
```

--------------------------------

### Build Disruptor Distribution

Source: https://lmax-exchange.github.io/disruptor/developer-guide/index.html

Build a distribution of the Disruptor project using Gradle.

```bash
$ ./gradlew clean build
```

--------------------------------

### Get RewindAction Enum Constant by Name

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/class-use/RewindAction.html

Retrieves a specific RewindAction enum constant by its name.

```APIDOC
## RewindAction.valueOf(String name)

### Description
Returns the enum constant of this type with the specified name.

### Method
`static RewindAction valueOf(java.lang.String name)`

### Parameters
* **name** (String) - The name of the enum constant to return.

### Return Value
The enum constant with the specified name.

### Throws
* `IllegalArgumentException` - if this enum type has no constant with the specified name.
```

--------------------------------

### SimpleBatchRewindStrategy Constructor

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Constructor for SimpleBatchRewindStrategy.

```APIDOC
## SimpleBatchRewindStrategy()

### Description
Batch rewind strategy that always rewinds.

### Constructor
`SimpleBatchRewindStrategy()`
```

--------------------------------

### Get Minimum Sequence Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequencer.html

Retrieves the minimum sequence value from all added gating sequences.

```java
long getMinimumSequence()
```

--------------------------------

### SequenceGroup.size() - Get Group Size

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/SequenceGroup.html

Returns the current number of sequences aggregated within the group.

```java
public int size()
```

--------------------------------

### handleOnStartException Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/IgnoreExceptionHandler.html

Handles exceptions that occur during the Disruptor's startup phase. This implementation logs the exception.

```java
public	void	handleOnStartException(java.lang.Throwable ex)

```

--------------------------------

### Get Buffer Size

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/AbstractSequencer.html

Returns the total capacity of the RingBuffer. This method is inherited from the Sequenced interface.

```java
public finalintgetBufferSize()
{
}
```

--------------------------------

### Gradle Properties for Signing

Source: https://lmax-exchange.github.io/disruptor/developer-guide/index.html

Configuration for Gradle's signing plugin. Ensure `signing.keyId` matches your GPG key ID, `signing.password` is your passphrase, and `signing.secretKeyRingFile` points to your private key.

```properties
signing.keyId=2657EDD1
signing.password=<passphrase used to protect your private key>
signing.secretKeyRingFile=/home/dev/.gnupg/secring.gpg
```

--------------------------------

### handleExceptionsFor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/dsl/class-use/ExceptionHandlerSetting.html

Overrides the default exception handler for a specific event handler within the Disruptor setup.

```APIDOC
## handleExceptionsFor

### Description
Overrides the default exception handler for a specific handler.

### Method Signature
`ExceptionHandlerSetting<T> handleExceptionsFor(EventHandlerIdentity eventHandler)`

### Parameters
*   **eventHandler** (`EventHandlerIdentity`) - The identity of the event handler for which to set the exception handler.
```

--------------------------------

### EventPoller Constructor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventPoller.html

Creates an event poller. It's recommended to use `RingBuffer.newPoller()` for automatic setup.

```APIDOC
## EventPoller Constructor

### Description
Creates an event poller. Most users will want `RingBuffer.newPoller(Sequence...)` which will set up the poller automatically.

### Parameters
* `dataProvider` - from which events are drawn
* `sequencer` - the main sequencer which handles ordering of events
* `sequence` - the sequence which will be used by this event poller
* `gatingSequence` - the sequences to gate on
```

--------------------------------

### Configure Disruptor with Producer Type and Wait Strategy

Source: https://lmax-exchange.github.io/disruptor/user-guide/index.html

Instantiate a Disruptor with specific producer type and wait strategy. Use ProducerType.SINGLE for single-producer scenarios and ProducerType.MULTI for multiple producers. Choose a WaitStrategy based on performance and resource constraints.

```java
public class LongEventMain
{
    public static void main(final String[] args)
    {
        //.....
        Disruptor<LongEvent> disruptor = new Disruptor(
            factory,
            bufferSize,
            DaemonThreadFactory.INSTANCE,
            ProducerType.SINGLE, __**(1)**
            new BlockingWaitStrategy() __**(2)**
        );
        //.....
    }
}
```

--------------------------------

### tryNext (batch)

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequenced.html

Attempts to claim a range of sequences for batch publishing, throwing an exception if capacity is insufficient.

```APIDOC
## tryNext (batch)

### Description
Attempt to claim the next n events in sequence for publishing. Will return the highest numbered slot if there is at least `requiredCapacity` slots available. Have a look at `next()` for a description on how to use this method.

### Method
```java
long tryNext(int n)
```

### Parameters
#### Path Parameters
- **n** (int) - the number of sequences to claim

### Returns
- `long`: the claimed sequence value

### Throws
- `InsufficientCapacityException`: thrown if there is no space available in the ring buffer.
```

--------------------------------

### tryPublishEvents with EventTranslatorOneArg, batchStartsAt, batchSize, and arguments

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempts to publish a batch of events with a single user-supplied argument to the ring buffer. Returns false if there was insufficient capacity.

```APIDOC
## tryPublishEvents

### Description
Allows one user supplied argument.

### Method
```java
public <A> boolean tryPublishEvents(EventTranslatorOneArg<E, A> translator, int batchStartsAt, int batchSize, A[] arg0)
```

### Type Parameters
- **A** - Class of the user supplied argument

### Parameters
#### Path Parameters
- **translator** (EventTranslatorOneArg<E, A>) - Required - The user specified translation for each event
- **batchStartsAt** (int) - Required - The first element of the array which is within the batch.
- **batchSize** (int) - Required - The actual size of the batch
- **arg0** (A[]) - Required - An array of user supplied arguments, one element per event.

### Returns
- true if the value was published, false if there was insufficient capacity.
```

--------------------------------

### remainingCapacity()

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Gets the remaining capacity of the sequencer or ring buffer. This indicates how many more entries can be added before the buffer is full.

```APIDOC
## remainingCapacity()

### Description
Get the remaining capacity for this ringBuffer or sequencer.

### Method
`int`

### Class/Interface
`com.lmax.disruptor.RingBuffer`
`com.lmax.disruptor.Sequenced`
`com.lmax.disruptor.MultiProducerSequencer`
`com.lmax.disruptor.SingleProducerSequencer`
```

--------------------------------

### SequenceGroup Constructors

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/SequenceGroup.html

Provides details on how to instantiate a SequenceGroup.

```APIDOC
## SequenceGroup()

### Description
Default Constructor for creating an empty SequenceGroup.

### Constructor
`public SequenceGroup()`
```

--------------------------------

### EventHandlerGroup.then

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/class-use/EventHandler.html

Sets up batch handlers to consume events from the ring buffer.

```APIDOC
## EventHandlerGroup.then

### Description
Set up batch handlers to consume events from the ring buffer.

### Method Signature
`<T> EventHandlerGroup<T> then(EventHandler<? super T>... handlers)`

### Parameters
- **handlers** (`EventHandler<? super T>...`)
```

--------------------------------

### DataProvider get Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/DataProvider.html

Retrieves the data item located at the specified sequence. This method is part of the DataProvider interface.

```java
T get (long sequence)
```

--------------------------------

### Try Publish Events with Variable Arguments

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Attempts to publish events with variable user-supplied arguments. Returns false if there is insufficient capacity.

```java
public boolean tryPublishEvents
(EventTranslatorVararg<E> translator,
 java.lang.Object[]... args)
```

--------------------------------

### Get Sequence Method

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/BatchEventProcessor.html

Retrieves the Sequence object associated with this EventProcessor. This is useful for tracking the progress of event consumption.

```java
public Sequence getSequence()
```

--------------------------------

### EventPoller Constructor

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/EventPoller.html

Creates an event poller. Typically, users will prefer `RingBuffer.newPoller(Sequence...)` for automatic setup.

```java
public	EventPoller	(DataProvider<T> 	dataProvider,
                   Sequencer	sequencer,
                   Sequence	sequence,
                   Sequence	gatingSequence)
```

--------------------------------

### EventHandlerGroup.handleEventsWith

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/class-use/EventHandler.html

Sets up batch handlers to handle events from the ring buffer.

```APIDOC
## EventHandlerGroup.handleEventsWith

### Description
Set up batch handlers to handle events from the ring buffer.

### Method Signature
`<T> EventHandlerGroup<T> handleEventsWith(EventHandler<? super T>... handlers)`

### Parameters
- **handlers** (`EventHandler<? super T>...`)
```

--------------------------------

### Sequence Constructor - Default

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/Sequence.html

Initializes a new Sequence with a default value of -1. Use when starting sequence tracking.

```java
public Sequence()

```

--------------------------------

### ExceptionHandler.handleOnStartException(Throwable)

Source: https://lmax-exchange.github.io/disruptor/javadoc/index-all.html

Callback to notify of an exception during `EventHandlerBase.onStart()`.

```APIDOC
## ExceptionHandler.handleOnStartException(Throwable)

### Description
Callback to notify of an exception during `EventHandlerBase.onStart()`.

### Method
`public void handleOnStartException(Throwable ex)`
```

--------------------------------

### Get Cursor Value

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/RingBuffer.html

Retrieves the current cursor value of the RingBuffer. The exact value depends on the underlying Sequencer implementation.

```java
public long getCursor()
```

--------------------------------

### AggregateEventHandler<T>

Source: https://lmax-exchange.github.io/disruptor/javadoc/allclasses-index.html

An aggregate collection of `EventHandler`s that get called in sequence for each event. Allows multiple handlers to process an event sequentially.

```APIDOC
## AggregateEventHandler<T>

### Description
An aggregate collection of `EventHandler`s that get called in sequence for each event.

### Usage
This class groups multiple `EventHandler` instances, ensuring they are invoked one after another for each event, creating a sequential processing chain.
```

--------------------------------

### remainingCapacity()

Source: https://lmax-exchange.github.io/disruptor/javadoc/com.lmax.disruptor/com/lmax/disruptor/MultiProducerSequencer.html

Gets the remaining capacity of the sequencer. This indicates how many slots are currently available in the ring buffer for new events.

```APIDOC
## remainingCapacity()

### Description
Get the remaining capacity for this sequencer.

### Returns
* (long) - The number of slots remaining.

### See Also
* `Sequenced.remainingCapacity()`
```
Tokens:
Raw