java.lang.Object
- com.lmax.disruptor.BatchEventProcessor<T>

Type Parameters:

T - event implementation storing the data for sharing during exchange or parallel coordination of an event.

All Implemented Interfaces:

EventProcessor, java.lang.Runnable
```
public final class BatchEventProcessor<T>
extends java.lang.Object
implements EventProcessor
```
Convenience class for handling the batching semantics of consuming entries from a RingBuffer and delegating the available events to an EventHandler.
If the EventHandler also implements LifecycleAware it will be notified just after the thread is started and just before the thread is shutdown.

Field Summary

Fields
Modifier and Type	Field	Description
`private BatchStartAware`	`batchStartAware`
`private DataProvider<T>`	`dataProvider`
`private EventHandler<? super T>`	`eventHandler`
`private ExceptionHandler<? super T>`	`exceptionHandler`
`private static int`	`HALTED`
`private static int`	`IDLE`
`private java.util.concurrent.atomic.AtomicInteger`	`running`
`private static int`	`RUNNING`
`private Sequence`	`sequence`
`private SequenceBarrier`	`sequenceBarrier`
`private TimeoutHandler`	`timeoutHandler`

Constructor Summary

Constructors
Constructor	Description
`BatchEventProcessor(DataProvider<T> dataProvider, SequenceBarrier sequenceBarrier, EventHandler<? super T> eventHandler)`	Construct a `EventProcessor` that will automatically track the progress by updating its sequence when the `EventHandler.onEvent(Object, long, boolean)` method returns.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`earlyExit()`
`private ExceptionHandler<? super T>`	`getExceptionHandler()`
`Sequence`	`getSequence()`	Get a reference to the `Sequence` being used by this `EventProcessor`.
`void`	`halt()`	Signal that this EventProcessor should stop when it has finished consuming at the next clean break.
`private void`	`handleEventException(java.lang.Throwable ex, long sequence, T event)`	Delegate to `ExceptionHandler.handleEventException(Throwable, long, Object)` on the delegate or the default `ExceptionHandler` if one has not been configured.
`private void`	`handleOnShutdownException(java.lang.Throwable ex)`	Delegate to `ExceptionHandler.handleOnShutdownException(Throwable)` on the delegate or the default `ExceptionHandler` if one has not been configured.
`private void`	`handleOnStartException(java.lang.Throwable ex)`	Delegate to `ExceptionHandler.handleOnStartException(Throwable)` on the delegate or the default `ExceptionHandler` if one has not been configured.
`boolean`	`isRunning()`
`private void`	`notifyShutdown()`	Notifies the EventHandler immediately prior to this processor shutting down
`private void`	`notifyStart()`	Notifies the EventHandler when this processor is starting up
`private void`	`notifyTimeout(long availableSequence)`
`private void`	`processEvents()`
`void`	`run()`	It is ok to have another thread rerun this method after a halt().
`void`	`setExceptionHandler(ExceptionHandler<? super T> exceptionHandler)`	Set a new `ExceptionHandler` for handling exceptions propagated out of the `BatchEventProcessor`

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

- Field Detail
  - IDLE
```
private static final int IDLE
```
    See Also:
    
    Constant Field Values
  - HALTED
```
private static final int HALTED
```
    See Also:
    
    Constant Field Values
  - RUNNING
```
private static final int RUNNING
```
    See Also:
    
    Constant Field Values
  - running
```
private final java.util.concurrent.atomic.AtomicInteger running
```
  - exceptionHandler
```
private ExceptionHandler<? super T> exceptionHandler
```
  - dataProvider
```
private final DataProvider<T> dataProvider
```
  - sequenceBarrier
```
private final SequenceBarrier sequenceBarrier
```
  - eventHandler
```
private final EventHandler<? super T> eventHandler
```
  - sequence
```
private final Sequence sequence
```
  - timeoutHandler
```
private final TimeoutHandler timeoutHandler
```
  - batchStartAware
```
private final BatchStartAware batchStartAware
```
- Constructor Detail
  - BatchEventProcessor
```
public BatchEventProcessor(DataProvider<T> dataProvider,
                           SequenceBarrier sequenceBarrier,
                           EventHandler<? super T> eventHandler)
```
    Construct a EventProcessor that will automatically track the progress by updating its sequence when the EventHandler.onEvent(Object, long, boolean) method returns.
    
    Parameters:
    
    dataProvider - to which events are published.
    
    sequenceBarrier - on which it is waiting.
    
    eventHandler - is the delegate to which events are dispatched.
- Method Detail
  - getSequence
```
public Sequence getSequence()
```
    Description copied from interface: EventProcessor
    
    Get a reference to the Sequence being used by this EventProcessor.
    
    Specified by:
    
    getSequence in interface EventProcessor
    
    Returns:
    
    reference to the Sequence for this EventProcessor
  - halt
```
public void halt()
```
    Description copied from interface: EventProcessor
    
    Signal that this EventProcessor should stop when it has finished consuming at the next clean break. It will call SequenceBarrier.alert() to notify the thread to check status.
    
    Specified by:
    
    halt in interface EventProcessor
  - isRunning
```
public boolean isRunning()
```
    Specified by:
    
    isRunning in interface EventProcessor
  - setExceptionHandler
```
public void setExceptionHandler(ExceptionHandler<? super T> exceptionHandler)
```
    Set a new ExceptionHandler for handling exceptions propagated out of the BatchEventProcessor
    
    Parameters:
    
    exceptionHandler - to replace the existing exceptionHandler.
  - run
```
public void run()
```
    It is ok to have another thread rerun this method after a halt().
    
    Specified by:
    
    run in interface java.lang.Runnable
    
    Throws:
    
    java.lang.IllegalStateException - if this object instance is already running in a thread
  - processEvents
```
private void processEvents()
```
  - earlyExit
```
private void earlyExit()
```
  - notifyTimeout
```
private void notifyTimeout(long availableSequence)
```
  - notifyStart
```
private void notifyStart()
```
    Notifies the EventHandler when this processor is starting up
  - notifyShutdown
```
private void notifyShutdown()
```
    Notifies the EventHandler immediately prior to this processor shutting down
  - handleEventException
```
private void handleEventException(java.lang.Throwable ex,
                                  long sequence,
                                  T event)
```
    Delegate to ExceptionHandler.handleEventException(Throwable, long, Object) on the delegate or the default ExceptionHandler if one has not been configured.
  - handleOnStartException
```
private void handleOnStartException(java.lang.Throwable ex)
```
    Delegate to ExceptionHandler.handleOnStartException(Throwable) on the delegate or the default ExceptionHandler if one has not been configured.
  - handleOnShutdownException
```
private void handleOnShutdownException(java.lang.Throwable ex)
```
    Delegate to ExceptionHandler.handleOnShutdownException(Throwable) on the delegate or the default ExceptionHandler if one has not been configured.
  - getExceptionHandler
```
private ExceptionHandler<? super T> getExceptionHandler()
```

Class BatchEventProcessor<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

IDLE

HALTED

RUNNING

running

exceptionHandler

dataProvider

sequenceBarrier

eventHandler

sequence

timeoutHandler

batchStartAware

Constructor Detail

BatchEventProcessor

Method Detail

getSequence

halt

isRunning

setExceptionHandler

run

processEvents

earlyExit

notifyTimeout

notifyStart

notifyShutdown

handleEventException

handleOnStartException

handleOnShutdownException

getExceptionHandler