BatchEventProcessor

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 and Description
`private DataProvider<T>`	`dataProvider`
`private EventHandler<? super T>`	`eventHandler`
`private ExceptionHandler<? super T>`	`exceptionHandler`
`private java.util.concurrent.atomic.AtomicBoolean`	`running`
`private Sequence`	`sequence`
`private SequenceBarrier`	`sequenceBarrier`
`private TimeoutHandler`	`timeoutHandler`

Constructor Summary

Constructors
Constructor and 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 and Description
`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.
`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)`
`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
  - running
```
private final java.util.concurrent.atomic.AtomicBoolean 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
```
- 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
  - 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

Class BatchEventProcessor<T>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

running

exceptionHandler

dataProvider

sequenceBarrier

eventHandler

sequence

timeoutHandler

Constructor Detail

BatchEventProcessor

Method Detail

getSequence

halt

isRunning

setExceptionHandler

run

notifyTimeout

notifyStart

notifyShutdown