reactor/reactor-core

Features

• Flow Control - Provides a demand-based backpressure system to regulate data production and prevent consumer overwhelm.
• Backpressure Controllers - Implements a sophisticated demand-based flow control system to prevent consumer overwhelm and resource exhaustion.
• Backpressure Coordination - Regulates data production speed through demand-based signaling to prevent consumer overwhelm and resource exhaustion.
• Reactive Stream Libraries - Provides a non-blocking foundation for composing asynchronous data pipelines based on the Reactive Streams specification.
• Collection Element Transformations - Provides functional operators to transform elements, filter them based on predicates, or signal errors.
• Reactive Stream Processing - Provides a complete toolkit for processing asynchronous sequences using non-blocking functional operators.
• Stream Subscriptions - Attaches consumers to data sequences to handle produced values, errors, and completion signals.
• Sequence Transformations - Provides a rich set of operators for mapping, flattening, and transforming asynchronous data sequences.
• Asynchronous Streams - Provides the fundamental interfaces for producing and consuming sequences of data emitted over time asynchronously.
• Demand-Based - Regulates flow by requesting specific quantities of data to prevent consumer overwhelm.
• Context Propagation - Implements mechanisms for capturing and transferring metadata across asynchronous execution boundaries without thread-local storage.
• Contextual Metadata Propagation - Stores immutable key-value pairs tied to a subscriber to propagate metadata across asynchronous boundaries.
• Parallel Workload Distribution - Subdivides data sequences into concurrent tasks to distribute the processing workload across multiple CPU cores.
• Asynchronous Stream Processing Frameworks - Acts as a comprehensive non-blocking foundation for composing asynchronous data pipelines on the JVM.
• Stream Combinators - Implements a comprehensive set of non-blocking operators for transforming, filtering, and combining asynchronous data streams.
• Asynchronous Value Representations - Provides Mono as a specialized representation for a non-blocking computation emitting zero or one value.
• Concurrent Thread Execution - Provides a comprehensive scheduler registry to manage thread execution and decouple signal processing from specific threads.
• Execution Context Management - Provides a scheduler registry to decouple signal processing from specific threads and manage concurrency.
• JVM Reactive Toolkits - Offers a comprehensive set of operators and types for orchestrating complex asynchronous workflows on the JVM.
• Stream Operator Chains - Allows the composition of asynchronous pipelines by linking stream operators sequentially to transform and filter data.
• Asynchronous Task Orchestration - Allows composing multiple asynchronous operations into complex sequences or fork-join structures.
• Backpressure Management - Implements a demand-based flow control system to regulate data production and prevent consumer overwhelm.
• Concurrency Schedulers - Provides a robust set of abstractions for managing the execution context and scheduling of asynchronous tasks.
• Scheduler-Based Concurrency Models - Decouples signal processing from specific threads using a pluggable scheduler registry to control timing and parallelism.
• Stream Windowing - Implements sophisticated windowing operators to group streaming data by time intervals or element counts.
• Single-Value Result Handling - Manages asynchronous computations that produce zero or one element with deterministic sequence generation and timeout handling.
• Event Sequence Verification - Compares step-by-step scenarios of expected values, errors, and completion events against actual signal sequences.
• Reactive Sequence Generation - Generates event streams from constants, iterables, suppliers, futures, and programmatic generators.
• Stream Aggregation - Reduces a sequence of emitted elements into a single summary value, collection, or boolean result.
• Predicate-Based Filters - Excludes elements from a stream based on predicates, type checks, or position-based constraints.
• Reactive Stream Testing - Verifies the behavior and timing of event streams using specialized publishers, subscribers, and schedulers.
• Virtual Time Testing - Replaces the real-time clock with a virtual scheduler to test time-based operators and long delays instantaneously.
• Functional Stream Transformations - Applies chains of functional operators to filter, transform, and handle errors for data flowing from a producer.
• Bounded Buffer Synchronization - Uses bounded buffers to synchronize production and consumption speeds.
• Sequence - Stores emitted elements and replays them to late subscribers based on a fixed count or time duration.
• Cold Publisher Generation - Supports the creation of cold publishers that restart the data sequence for each unique subscriber.
• Interval Sampling - Selects a subset of stream elements based on time intervals, windows, or timeout triggers.
• Parallel Processing - Distributes a data stream across multiple processing rails to execute transformations concurrently.
• Parallel Data Merging - Combines results from multiple parallel processing rails back into a single sequential stream.
• Synchronous Sequence Generation - Enables the production of data sequences using stateful generators that emit items one-by-one.
• Stream Mathematical Aggregations - Calculates sums, averages, minimums, and maximums across streams of numeric data.
• Chain Checkpoints - Adds markers to reactive chains to pinpoint failure locations during debugging.
• Verification - Provides assertions to verify that specific context was correctly passed through an operator chain.
• Event Sequence Tracing - Logs the entire sequence of emissions, errors, and backpressure requests to analyze signal behavior.
• Reactive Stream Retries - Provides the ability to automatically re-subscribe to an upstream source when a stream terminates with an error.
• Last Value Caching - Caches the most recent signal and serves it to subsequent subscribers with configurable TTL expiration.
• Asynchronous Task Execution - Executes asynchronous tasks using a specialized work-stealing scheduler for high-performance task dispatching.
• Work-Stealing Schedulers - Utilizes a fork-join scheduler to distribute data streams across multiple processing rails via work-stealing.
• Execution Context Switching - Enables shifting the execution thread or scheduler for subsequent operations to maintain thread affinity.
• Exponential Backoff Retries - Implements sophisticated retry operators including exponential backoff to handle transient failures.
• Blocking Operation Handlers - Offloads synchronous blocking operations to dedicated worker threads to prevent event loop starvation.
• Reactive API Bridging - Offers utilities to wrap legacy listener-based or callback APIs into reactive Flux and Mono types.
• Value-Based Stream Generation - Generates event streams from constants, collections, ranges, or enumerated values using factory methods.
• Error Interception Handlers - Implements programmable handlers to intercept and transform exceptions thrown during operator execution.
• Assembly-Time Trace Capture - Provides specialized assembly-time trace capture to accurately locate errors within complex asynchronous operator chains.
• Asynchronous API Bridging - Provides utilities to convert listener-based event sources into reactive streams with configurable overflow strategies.
• Asynchronous Operation Chaining - Enables wrapping sequences of asynchronous operations into reusable functions for consistent application across subscribers.
• Boolean Predicates - Includes operators that evaluate stream elements against predicates to emit a single boolean summary.
• Concurrent Emission Handling - Handles concurrent data production across multiple threads using failure handlers to prevent reactive specification violations.
• Data Broadcasting - Shares a single data source among several subscribers and controls when the upstream subscription triggers.
• Error Recovery - Provides operators to intercept errors and switch to fallback publishers or return default values.
• Exception Traceback Capture - Records stack traces during the assembly of the operator chain to pinpoint the exact location of failures.
• Execution Schedulers - Allows specifying the thread that handles the initial subscription process and subsequent operator chain execution.
• Subscription Cancellation Cascades - Stops a data source from producing further elements and triggers resource cleanup via a disposable handle.
• Historical Event Replay - Delivers previously emitted values to new subscribers before transitioning to the live data stream.
• Imperative-Reactive Bridges - Bridges non-reactive callbacks or listener-based APIs into reactive streams using configurable overflow strategies.
• Manual Event Signaling - Produces data and terminal signals in a standalone fashion to drive a stream for multiple subscribers.
• Multicast Stream Sharing - Shares a single upstream data source among multiple subscribers using reference counting to manage subscription lifecycles.
• Non-Destructive Signal Peeking - Executes side-effect actions upon signals without altering the stream of data.
• Reactive Stream Spans - Tracks the end-to-end lifecycle of reactive sequences to generate spans for distributed tracing.
• Reactive Stream Adaptation - Converts a publisher into a standard flow publisher to ensure compatibility across different reactive implementations.
• Reactive Subscription Management - Groups multiple active subscriptions into a single handle to cancel them simultaneously or replace them atomically.
• Reactive Value Combinations - Merges the most recent values from multiple asynchronous sources using custom combinator functions.
• Demand Reshaping - Modifies downstream demand by batching requests or prefetching items to optimize throughput.
• Sequence Buffering - Groups stream elements into collections based on size, duration, or specific boundaries.
• Signal Performance Metrics - Records performance metrics at specific stages of a stream to analyze signal behavior and throughput.
• Signal Replay Buffers - Stores a history of emitted items to deliver them to late subscribers who join after the source has started.
• Stream Element Grouping - Splits a data stream into multiple sub-streams by partitioning elements that share a common key.
• Subscription-Triggered Emissions - Defines whether a data sequence restarts for every subscriber or shares a single active emission.
• Synchronous API Bridging - Blocks execution to retrieve a value or converts a reactive stream into a standard iterable or future.
• Asynchronous Schedulers - Defines execution contexts to shift task processing across different thread pools for non-blocking execution.
• Assembly-Time Tracing - Marks points in the operator chain during construction to provide precise tracebacks for upstream errors.
• Reactive Path Probing - Tracks subscription, request, and cancellation events to verify which logical branches of the pipeline were executed.
• Callback-to-Stream Adapters - Wraps legacy callback or listener-based APIs into reactive streams to signal values, completion, or errors.

Star history