Location>code7788 >text

Reactive Streams introduction to Reactive Programming

Popularity：694 ℃/2025-03-07 13:51:34

Reactive Streams is a type used forStandardized specifications for asynchronous stream processing, aims to solve problems such as backpressure management, resource consumption and response speed in traditional asynchronous programming.

1. Core concept

  1. ‌Basic Model‌

    • ‌Publisher‌: Responsible for generating data streams, such as file reading or real-time data source‌.

    • ‌Subscriber‌: Receive and process data, and dynamically control the data flow rate.

    • ‌Subscription‌: As the link between the two, it transmits backpressure requests (such as data volume requirements).

    • ‌Processor‌: It has both publisher and subscriber roles, and is used for intermediate data conversion.

      Data flow example‌：

      Publisher --(onSubscribe)--> Subscriber  
Subscriber --(request(n))--> Publisher  
Publisher --(onNext(data))--> Subscriber

  2. ‌Core objectives‌

    • ‌Non-blocking backpressure‌: Subscribers passrequest(n)Declare the amount of data that can be processed and the publisher pushes it on demand to avoid resource exhaustion or data loss caused by mismatch in processing speed‌.
    • ‌Asynchronous Boundaries‌: Decoupling of data production and consumption, supporting efficient collaboration across threads or networks‌.
    • ‌Bounded queue‌: Publishers maintain limited buffers to avoid memory overflow.
    • ‌Dynamic adjustment‌: Subscribers adjust the request volume in real time according to processing capabilities (such as the initial onerequest(1), and then request the next one after processing).

2. Key Features

  1. ‌Event-driven and declarative programming‌

    • Processing is triggered immediately when data arrives, rather than polling or blocking waiting, reducing latency. Developers use declarative APIs (e.g.map、filter) describes processing logic, rather than manually controlling the process‌.

  2. ‌Flow control mechanism‌

    • ‌Pull Model‌: Subscribers actively request data, and the initiative is controlled by consumers (compare the traditional push model).
    • ‌Dynamic adjustment‌: Subscribers can dynamically adjust the request rate based on processing power.

  3. ‌Asynchronous non-blocking‌

    • It realizes efficient resource utilization based on callbacks or responsive frameworks (such as Reactor, RxJava) to avoid thread blocking.

    • passpublishOn/subscribeOnSpecifies the execution thread to separate I/O-intensive and compute-intensive tasks.

  4. ‌Operator richness‌

    • ‌Conversion Class‌：map(map),flatMap(Asynchronously expand).
    • ‌Filtering‌：filter(filter),take(n)(Take the first N items).
    • ‌Combination class‌：merge(merged streams),zip(Multi-stream aggregation).

3. Typical application scenarios

  1. ‌High throughput real-time data processing

    • Such as real-time tweet analysis on social media and data flow processing of IoT devices.

  2. ‌Microservice communication

    • Asynchronous messaging between services, combined with backpressure to avoid service avalanches‌.

  3. ‌Resource-sensitive tasks

    • File/database streaming read and write to reduce memory usage‌.
    ‌Scene‌ ‌Problem Challenge‌ ‌Reactive Streams Solutions‌
    ‌Real-time data processing‌ High throughput, low latency requirements Backpressure control + non-blocking I/O (such as Kafka stream processing)
    ‌Microservice communication‌ Service avalanche, resource competition Asynchronous messaging + circuit breaker mechanism (such as RSocket)
    ‌Responsive Web Services‌ Thread blocking under high concurrent connections Non-blocking servers (such as Netty + Spring WebFlux)
    ‌Big data stream processing‌ Memory overflow, processing delay Batch pull + backpressure buffering (such as Flink integration)

4. Mainstream implementation framework

​ From the previous article, we can see that Reactive Streams is essentially a set of standardized interface specifications. Its core value lies in establishing a unified contract for backpressure mechanisms for asynchronous stream processing. This specification itself does not provide specific implementations, but rather lays the underlying interoperability foundation for reactive programming by defining core components such as Publisher/Subscriber and their interaction rules.

​ In industrial practice, based on this specification, multiple mature technology implementation solutions have been derived (such as Project Reactor, RxJava, Akka Streams, etc.), and these frameworks have formed a distinctive technology ecosystem by extending the core interface. For developers, multi-dimensional evaluation is required based on key dimensions such as throughput requirements, backpressure processing strategies, thread scheduling models in the business scenario, combined with framework characteristics and community ecology, and ultimately achieving accurate technical selection. These implementation frameworks not only fully support the core principles of Reactive Manifesto, but also provide a standardized toolchain for building flexible and responsive distributed systems through rich operators and configuration strategies.

4.1. Reactor (Spring ecosystem first choice)‌

  • ‌Core Type‌：Mono(0/1 element stream),Flux(0-N element stream).
  • Key Features:
    • Deeply integrate the Spring ecosystem (such as WebFlux, Spring Data Reactive).
    • Supports rich backpressure strategies (Buffer、Drop、Latest）。
    • Provides 100+ operators (map、flatMap、zip）。
  • Applicable scenarios:
    • High concurrency web service (replaces Spring MVC).
    • Responsive communication between microservices (such as RSocket).
  • ‌Official website‌：Project Reactor

‌4.2. RxJava (complex event stream processing)‌

  • ‌Core Type‌：Observable(Not backpressure flow),Flowable(Backpressure flow).
  • Key Features:
    • Supports 300+ operators, the most comprehensive responsive library.
    • Compatible with Java 6+ and Android platforms.
    • Provide thread scheduling (observeOn、subscribeOn）。
  • Applicable scenarios:
    • Android application asynchronous tasks.
    • Complex event stream merge/transformation (such as multi-data source aggregation).
  • ‌Official website‌：ReactiveX/RxJava

‌4.3. Akka Streams (Distributed Stream Processing)‌

  • ‌Core concept‌：Source(Publisher),Flow(processor),Sink(Subscriber).
  • Key features: Based on the Actor model, it supports distributed fault tolerance.
    • Built-in backpressure propagation, no manual configuration is required.
    • Streaming DSL (domain-specific language) is available.
  • Applicable scenarios:
    • Distributed data pipelines (such as Kafka stream processing).
    • High fault tolerance real-time calculation (such as financial risk control).
  • ‌Official website‌：Akka Streams

‌4.4. Java Flow API (native lightweight solution)‌

  • ‌Core category‌：、、。
  • Key Features:
    • Java 9+ native support, no third-party dependencies are required.
    • Provide basic backpressure control (request(n)）。
    • Compatible with other Reactive Streams implementations.
  • Applicable scenarios:
    • Lightweight responsive tool development.
    • Compatibility with other frameworks.
  • ‌document‌：Java 9 Flow API

‌4.5. RSocket (responsive communication protocol)‌

  • Core features:
    • The binary protocol based on Reactive Streams supports TCP/WebSocket.
    • Four interactive modes are available:Request-Response、Fire-and-Forget、Stream、Channel。
  • Applicable scenarios:
    • Cross-language microservice communication (Java, Go,).
    • Real-time bidirectional data flow (such as IoT device control).
  • ‌Integration Framework‌:
    • Reactor（Spring RSocket）、RxJava、Kotlin Coroutines。
  • ‌Official website‌：RSocket

‌4.6. Selection comparison table‌

‌frame‌ ‌Technology Ecology‌ ‌Backpressure support‌ ‌Applicable scenarios‌ ‌Learning Cost‌
‌Reactor‌ Spring/WebFlux powerful Web services, microservice communication middle
‌RxJava‌ Android/Java powerful Mobile, complex event flow high
‌Akka Streams‌ Akka/Scala automatic Distributed systems, big data pipelines high
‌Java Flow‌ Java native Base Lightweight tools, compatibility adaptation Low
‌RSocket‌ Multilingual (cross-platform) powerful Real-time communication, IoT middle

Select a framework according to project requirements:Spring Eco-Priority Reactor‌，‌RxJava for Android‌，‌Akka Streams for distributed systems‌，‌Java Flow for lightweight scenarios‌，‌RSocket for cross-language communication‌。

V. Conclusion

  1. ‌value‌
    • ‌Unified norms‌: Solve the compatibility issues of different responsive libraries.
    • ‌Standardized integration‌: Java 9 has included Reactive Streams interfacekind.
  2. ‌challenge‌
    • ‌Complexity‌: Asynchronous callback logic needs to be designed with caution to avoid nested hell‌.
    • ‌Debugging difficulty‌: Asynchronous link tracing and error handling require specialized tools (such as Reactor Debug Agent).
<Previous Next>