All Classes and Interfaces
Class
Description
Base class for the various sequencer types (single/multi).
An aggregate collection of
EventHandlers that get called in sequence for each event.Used to alert
EventProcessors waiting at a SequenceBarrier of status changes.Convenience class for handling the batching semantics of consuming entries from a
RingBuffer
and delegating the available events to an EventHandler.Strategy for handling a rewindableException when processing an event.
Blocking strategy that uses a lock and condition variable for
EventProcessors waiting on a barrier.Busy Spin strategy that uses a busy spin loop for
EventProcessors waiting on a barrier.Provides a repository mechanism to associate
EventHandlers with EventProcessorsImplementors of this interface must provide a single long value
that represents their current cursor value.
Access to a ThreadFactory instance.
Typically used to decouple classes from
RingBuffer to allow easier testingA DSL-style API for setting up the disruptor pattern around a ring buffer
(aka the Builder pattern).
Called by the
RingBuffer to pre-populate all the events to fill the RingBuffer.Callback interface to be implemented for processing events as they become available in the
RingBufferA group of
EventProcessors used as part of the Disruptor.Experimental poll-based interface for the Disruptor.
A callback used to process events
Indicates the result of a call to
EventPoller.poll(Handler)An EventProcessor needs to be an implementation of a runnable that will poll for events from the
RingBuffer
using the appropriate wait strategy.A factory interface to make it possible to include custom event processors in a chain:
Wrapper class to tie together a particular event processing stage
Pulls together the low-level data access and sequencing operations of
RingBufferWrite interface for
RingBuffer.Implementations translate (write) data representations into events claimed from the
RingBuffer.Implementations translate another data representations into events claimed from the
RingBufferImplementations translate another data representations into events claimed from the
RingBufferImplementations translate another data representations into events claimed from the
RingBufferImplementations translate another data representations into events claimed from the
RingBufferStrategy for handling a rewindableException that will eventually delegate the exception to the
ExceptionHandler after a specified number of attempts have been made.Callback handler for uncaught exceptions in the event processing cycle of the
BatchEventProcessorProvides static methods for accessing a default
ExceptionHandler object.A support class used as part of setting an exception handler for a specific event handler.
A mutable exception handler wrapper
Convenience implementation of an exception handler that uses the standard JDK logging
of
System.Logger to log the exception as System.Logger.Level.ERROR and re-throw
it wrapped in a RuntimeExceptionHides a group of Sequences behind a single Sequence
Convenience implementation of an exception handler that uses the standard JDK logging
of
System.Logger to log the exception as System.Logger.Level.INFOException thrown when it is not possible to insert a value into
the ring buffer without it wrapping the consuming sequences.
Implement this interface in your
EventHandler to be notified when a thread for the
BatchEventProcessor starts and shuts down.Variation of the
BlockingWaitStrategy that attempts to elide conditional wake-ups when
the lock is uncontended.Variation of the
TimeoutBlockingWaitStrategy that attempts to elide conditional wake-ups
when the lock is uncontended.Coordinator for claiming sequences for access to a data structure while tracking dependent
Sequences.Strategy for handling a rewindableException that will pause for a specified amount of nanos.
No operation version of a
EventProcessor that simply tracks a Sequence.Sequence that follows (by wrapping) another sequence
Phased wait strategy for waiting
EventProcessors on a barrier.SequenceBarrier handed out for gating EventProcessors on a cursor sequence and optional dependent EventProcessor(s),
using the given WaitStrategy.Defines producer types to support creation of RingBuffer with correct sequencer and publisher.
Callback interface to be implemented for processing events as they become available in the
RingBuffer
with support for throwing a RewindableException when an even cannot be processed currently but may succeed on retry.A special exception that can be thrown while using the
BatchEventProcessor.The result returned from the
BatchRewindStrategy that decides whether to rewind or throw the exceptionRing based store of reusable entries containing the data representing
an event being exchanged between event producer and
EventProcessors.Concurrent sequence class used for tracking the progress of
the ring buffer and event processors.
Coordination barrier for tracking the cursor for publishers and sequence of
dependent
EventProcessors for processing a data structureOperations related to the sequencing of items in a
RingBuffer.Provides static methods for managing a
SequenceGroup object.Coordinates claiming sequences for access to a data structure while tracking dependent
SequencesUsed 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.Batch rewind strategy that always rewinds
Coordinator for claiming sequences for access to a data structure while tracking dependent
Sequences.Only used when assertions are enabled.
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.Deprecated.
Use Thread.onSpinWait() directly.
Blocking strategy that uses a lock and condition variable for
EventProcessors waiting on a barrier.Wait strategies may throw this Exception to inform callers that a
message has not been detected within a specific time window.
Set of common functions used by the Disruptor.
Strategy employed for making
EventProcessors wait on a cursor Sequence.Yielding strategy that uses a Thread.yield() for
EventProcessors waiting on a barrier
after an initially spinning.