All Classes

Class	Description
AbstractSequencer	Base class for the various sequencer types (single/multi).
AggregateEventHandler<T>	An aggregate collection of EventHandlers that get called in sequence for each event.
AlertException	Used to alert EventProcessors waiting at a SequenceBarrier of status changes.
BasicExecutor
BatchEventProcessor<T>	Convenience class for handling the batching semantics of consuming entries from a RingBuffer and delegating the available events to an EventHandler.
BatchStartAware
BlockingWaitStrategy	Blocking strategy that uses a lock and condition variable for EventProcessors waiting on a barrier.
BusySpinWaitStrategy	Busy Spin strategy that uses a busy spin loop for EventProcessors waiting on a barrier.
ConsumerInfo
ConsumerRepository<T>	Provides a repository mechanism to associate EventHandlers with EventProcessors
Cursored	Implementors of this interface must provide a single long value that represents their current cursor value.
DaemonThreadFactory	Access to a ThreadFactory instance.
DataProvider<T>
Disruptor<T>	A DSL-style API for setting up the disruptor pattern around a ring buffer (aka the Builder pattern).
EventFactory<T>	Called by the RingBuffer to pre-populate all the events to fill the RingBuffer.
EventHandler<T>	Callback interface to be implemented for processing events as they become available in the RingBuffer
EventHandlerGroup<T>	A group of EventProcessors used as part of the Disruptor.
EventPoller<T>	Experimental poll-based interface for the Disruptor.
EventPoller.Handler<T>
EventPoller.PollState
EventProcessor	An EventProcessor needs to be an implementation of a runnable that will poll for events from the RingBuffer using the appropriate wait strategy.
EventProcessorFactory<T>	A factory interface to make it possible to include custom event processors in a chain:
EventProcessorInfo<T>	Wrapper class to tie together a particular event processing stage
EventReleaseAware
EventReleaser
EventSequencer<T>
EventSink<E>
EventTranslator<T>	Implementations translate (write) data representations into events claimed from the RingBuffer.
EventTranslatorOneArg<T,A>	Implementations translate another data representations into events claimed from the RingBuffer
EventTranslatorThreeArg<T,A,B,C>	Implementations translate another data representations into events claimed from the RingBuffer
EventTranslatorTwoArg<T,A,B>	Implementations translate another data representations into events claimed from the RingBuffer
EventTranslatorVararg<T>	Implementations translate another data representations into events claimed from the RingBuffer
ExceptionHandler<T>	Callback handler for uncaught exceptions in the event processing cycle of the BatchEventProcessor
ExceptionHandlerSetting<T>	A support class used as part of setting an exception handler for a specific event handler.
ExceptionHandlerWrapper<T>
FatalExceptionHandler	Convenience implementation of an exception handler that using standard JDK logging to log the exception as Level.SEVERE and re-throw it wrapped in a RuntimeException
FixedSequenceGroup	Hides a group of Sequences behind a single Sequence
IgnoreExceptionHandler	Convenience implementation of an exception handler that using standard JDK logging to log the exception as Level.INFO
InsufficientCapacityException	Exception thrown when it is not possible to insert a value into the ring buffer without it wrapping the consuming sequences.
LhsPadding
LifecycleAware	Implement this interface in your EventHandler to be notified when a thread for the BatchEventProcessor starts and shuts down.
LiteBlockingWaitStrategy	Variation of the BlockingWaitStrategy that attempts to elide conditional wake-ups when the lock is uncontended.
LiteTimeoutBlockingWaitStrategy	Variation of the TimeoutBlockingWaitStrategy that attempts to elide conditional wake-ups when the lock is uncontended.
MultiProducerSequencer	Coordinator for claiming sequences for access to a data structure while tracking dependent Sequences.
NoOpEventProcessor	No operation version of a EventProcessor that simply tracks a Sequence.
NoOpEventProcessor.SequencerFollowingSequence	Sequence that follows (by wrapping) another sequence
PhasedBackoffWaitStrategy	Phased wait strategy for waiting EventProcessors on a barrier.
ProcessingSequenceBarrier	SequenceBarrier handed out for gating EventProcessors on a cursor sequence and optional dependent EventProcessor(s), using the given WaitStrategy.
ProducerType	Defines producer types to support creation of RingBuffer with correct sequencer and publisher.
RhsPadding
RingBuffer<E>	Ring based store of reusable entries containing the data representing an event being exchanged between event producer and EventProcessors.
RingBufferFields<E>
RingBufferPad
Sequence	Concurrent sequence class used for tracking the progress of the ring buffer and event processors.
SequenceBarrier	Coordination barrier for tracking the cursor for publishers and sequence of dependent EventProcessors for processing a data structure
Sequenced
SequenceGroup	A Sequence group that can dynamically have Sequences added and removed while being thread safe.
SequenceGroups	Provides static methods for managing a SequenceGroup object.
Sequencer	Coordinates claiming sequences for access to a data structure while tracking dependent Sequences
SequenceReportingEventHandler<T>	Used by the BatchEventProcessor to set a callback allowing the EventHandler to notify when it has finished consuming an event if this happens after the EventHandler.onEvent(Object, long, boolean) call.
SingleProducerSequencer	Coordinator for claiming sequences for access to a data structure while tracking dependent Sequences.
SingleProducerSequencerFields
SingleProducerSequencerPad
SleepingWaitStrategy	Sleeping strategy that initially spins, then uses a Thread.yield(), and eventually sleep (LockSupport.parkNanos(n)) for the minimum number of nanos the OS and JVM will allow while the EventProcessors are waiting on a barrier.
ThreadHints	This class captures possible hints that may be used by some runtimes to improve code performance.
TimeoutBlockingWaitStrategy
TimeoutException
TimeoutHandler
Util	Set of common functions used by the Disruptor
Value
WaitStrategy	Strategy employed for making EventProcessors wait on a cursor Sequence.
WorkerPool<T>	WorkerPool contains a pool of WorkProcessors that will consume sequences so jobs can be farmed out across a pool of workers.
WorkerPoolInfo<T>
WorkHandler<T>	Callback interface to be implemented for processing units of work as they become available in the RingBuffer.
WorkProcessor<T>	A WorkProcessor wraps a single WorkHandler, effectively consuming the sequence and ensuring appropriate barriers.
YieldingWaitStrategy	Yielding strategy that uses a Thread.yield() for EventProcessors waiting on a barrier after an initially spinning.