reactivestreams

Reactive Streams is a standard for asynchronous stream processing with non-blocking backpressure. It defines a small, interoperable set of interfaces that enable libraries and runtimes to work together when publishing and consuming data streams.

The initiative originated in the mid-2010s (with contributions from Netflix, Pivotal, Red Hat, and others) to unify varying backpressure approaches for streaming on the JVM. The specification specifies a contract that libraries can implement to ensure interoperability, so different frameworks and adapters can compose with one another.

Core concepts and API elements center on four interfaces: Publisher, Subscriber, Subscription, and Processor (where Processor extends both Publisher and Subscriber). The typical lifecycle begins with a Publisher subscribing a Subscriber. The Subscriber receives an onSubscribe call containing a Subscription, through which it signals demand by calling request(n). The Publisher then emits at most n items via onNext, followed by onComplete or onError if the stream ends. A Processor acts as both Subscriber and Publisher, enabling in-stream transformations. The spec requires serialized signaling among onSubscribe, onNext, onError, and onComplete, and expects proper handling of cancellation and backpressure.

Key ideas include backpressure, demand-driven data flow, and asynchronous, non-blocking processing. The Java standard library’s Flow API (introduced in Java 9) aligns with Reactive Streams, providing a standard foundation for reactive stream primitives and interoperability.

Ecosystem and influence: major implementations include RxJava, Project Reactor, Akka Streams, and Spring WebFlux, among others. The standard has shaped how modern reactive libraries approach interoperability and has become a baseline for building and composing asynchronous data pipelines.