LMAX-Exchange/disruptor
Disruptor
The Disruptor is a lock-free inter-thread messaging library and high-performance event bus. It implements a concurrent ring buffer designed for high-concurrency and low-latency message sequencing.
The project utilizes a specific messaging architecture to eliminate lock contention, enabling high-throughput event routing and the exchange of continuous event streams between threads. It ensures strict first-in-first-out ordering and immediate data visibility across processing threads.
The library provides capabilities for lock-free data streaming, sequential data ordering, and sequence-based event distribution. These mechanisms coordinate producers and consumers to maintain strict processing order and minimize synchronization overhead.
Features
- Ring Buffers - Implements a high-performance concurrent ring buffer to sequence events with minimal garbage collection.
- Lock-Free Thread Communication - Facilitates high-performance event exchange between threads using lock-free concurrency primitives.
- High-Performance Event Routing - Provides high-throughput event routing to consumer handlers without the overhead of traditional locking.
- Low-Latency Concurrency Patterns - Applies low-latency concurrency patterns to move data between threads with minimal delay and high throughput.
- Lock-Free Buffers - Utilizes lock-free buffers to coordinate data access between producers and consumers without kernel locks.
- Event Bus Architectures - Implements a high-performance event bus for sequencing and distributing events in a strict FIFO order.
- LMAX Disruptor Pattern Implementations - Implements the LMAX Disruptor pattern to achieve ultra-low latency by eliminating lock contention.
- Message Ordering Management Systems - Maintains strict first-in-first-out message ordering based on the sequence of claims.
- Sequence Claiming - Uses a sequence claiming mechanism to allow multiple producers to write to the buffer without contention.
- Immediate Data Visibility - Ensures immediate data visibility across processing threads to maintain consistency in the event stream.
- Memory Barriers - Employs hardware-level memory barriers to ensure immediate data visibility across processing threads.
- Dependency-Based Gating - Provides consumer gating to ensure a strict linear processing order across multiple event handlers.
- Sequence-Based Event Distribution - Distributes events to specific handlers using sequence-based logic to ensure each event is processed by exactly one consumer.
- Cache-Line Padding - Implements cache-line padding to eliminate false sharing and maximize CPU cache efficiency.
- Language Toolkits - High-performance inter-thread messaging library.
- Utility Libraries - High-performance inter-thread messaging library.
