All Classes and Interfaces
Class
Description
Base class for the various sequencer types (single/multi).
An aggregate collection of
EventHandler
s that get called in sequence for each event.Used to alert
EventProcessor
s 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
.Blocking strategy that uses a lock and condition variable for
EventProcessor
s waiting on a barrier.Busy Spin strategy that uses a busy spin loop for
EventProcessor
s waiting on a barrier.Provides a repository mechanism to associate
EventHandler
s with EventProcessor
sImplementors of this interface must provide a single long value
that represents their current cursor value.
Access to a ThreadFactory instance.
A 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
RingBuffer
A group of
EventProcessor
s used as part of the Disruptor
.Experimental poll-based interface for the Disruptor.
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
Implementations translate (write) data representations into events claimed from the
RingBuffer
.Implementations translate another data representations into events claimed from the
RingBuffer
Implementations translate another data representations into events claimed from the
RingBuffer
Implementations translate another data representations into events claimed from the
RingBuffer
Implementations translate another data representations into events claimed from the
RingBuffer
Callback handler for uncaught exceptions in the event processing cycle of the
BatchEventProcessor
Provides static methods for accessing a default
ExceptionHandler
object.A support class used as part of setting an exception handler for a specific event handler.
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
Hides a group of Sequences behind a single Sequence
Convenience implementation of an exception handler that using standard JDK logging to log
the exception as
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
Sequence
s.No operation version of a
EventProcessor
that simply tracks a Sequence
.Sequence that follows (by wrapping) another sequence
Phased wait strategy for waiting
EventProcessor
s on a barrier.SequenceBarrier
handed out for gating EventProcessor
s 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.
Ring based store of reusable entries containing the data representing
an event being exchanged between event producer and
EventProcessor
s.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
EventProcessor
s for processing a data structureProvides static methods for managing a
SequenceGroup
object.Coordinates claiming sequences for access to a data structure while tracking dependent
Sequence
sUsed 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.Coordinator for claiming sequences for access to a data structure while tracking dependent
Sequence
s.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
EventProcessor
s are waiting on a barrier.This class captures possible hints that may be used by some
runtimes to improve code performance.
Set of common functions used by the Disruptor
Strategy employed for making
EventProcessor
s wait on a cursor Sequence
.WorkerPool contains a pool of
WorkProcessor
s that will consume sequences so jobs can be farmed out across a pool of workers.Callback interface to be implemented for processing units of work as they become available in the
RingBuffer
.A
WorkProcessor
wraps a single WorkHandler
, effectively consuming the sequence
and ensuring appropriate barriers.Yielding strategy that uses a Thread.yield() for
EventProcessor
s waiting on a barrier
after an initially spinning.