Reactive Streams Introduction

Java Streams

19.1 Overview of Reactive Programming

Reactive programming is a paradigm focused on asynchronous data flow, non-blocking execution, and responsive systems that can handle data streams dynamically and efficiently. Unlike traditional programming models that are often synchronous and blocking, reactive programming embraces events and streams of data that can be processed as they arrive, enabling highly scalable and resilient applications.

Core Principles of Reactive Programming

• Asynchronous Data Flow: Data is emitted over time, and consumers react to new data as it becomes available. The flow is event-driven rather than sequential.
• Non-blocking Execution: Reactive systems avoid waiting (blocking) on operations. Instead, they register callbacks or handlers that are triggered when data or events occur, freeing up threads for other tasks.
• Backpressure: A mechanism that allows consumers to control the rate at which they receive data from producers, preventing overload and ensuring system stability.

The Reactive Streams Specification

To standardize reactive programming in Java, the Reactive Streams specification defines a minimal API to handle asynchronous stream processing with backpressure. This specification is the foundation for many reactive libraries and is included as the java.util.concurrent.Flow API in Java 9+.

Key Components and Terminology

• Publisher : Produces data asynchronously and publishes it to one or more Subscribers.
• Subscriber : Consumes data items emitted by a Publisher. It receives notifications for new data, completion, or errors.
• Subscription: Represents a link between Publisher and Subscriber. It allows the Subscriber to request data and cancel the subscription.
• Processor<T, R>: A hybrid component that acts both as a Subscriber (consumes data) and Publisher (emits transformed data), enabling data processing pipelines.

Conceptual Flow: Reactive vs. Synchronous

Visualizing Reactive Streams Flow

Publisher  --->  Subscription  --->  Subscriber
   |                ↑                 |
   |                |   request(n)    |
   |--------------> |-----------------|
   |                |                 |
   | emit data (onNext)               |
   |--------------> |-----------------|

• The Subscriber requests n items via the Subscription.
• The Publisher emits up to n items asynchronously.
• This cycle continues until the stream completes or errors out.
• The backpressure mechanism ensures the Subscriber is never overwhelmed.

In essence, reactive programming transforms how we deal with data streams by making them asynchronous, non-blocking, and controllable through backpressure, enabling systems that are highly responsive and resilient to varying workloads. This new paradigm addresses the limitations of traditional synchronous or event-driven push/pull models by explicitly coordinating the data flow between producers and consumers.

19.2 Differences Between Java Streams and Reactive Streams

Java Streams and Reactive Streams both deal with processing sequences of data, but they differ fundamentally in design, execution model, and use cases. Understanding these differences helps choose the right tool for your needs.

Conceptual Differences

Key Technical Differences

• Pull vs Push: Java Streams pull elements on demand during terminal operations. Reactive Streams push data asynchronously as it becomes available, requiring Subscribers to signal readiness via backpressure.

• Finite vs Potentially Infinite: Java Streams are designed for finite data sources (collections, arrays). Reactive Streams can handle infinite data flows like sensor data, user events, or live feeds.

• Error Handling: In Java Streams, exceptions interrupt the flow immediately. Reactive Streams propagate errors through the onError callback, allowing subscribers to react gracefully.

• Lifecycle and Cancellation: Reactive Streams provide Subscription that allows subscribers to cancel or limit data flow. Java Streams terminate naturally after processing all elements.

Code Contrast: Filtering and Summing Integers

Java Streams (Synchronous, Pull-based):

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

int sum = numbers.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();

System.out.println("Sum of even numbers: " + sum);

Reactive Streams (Flow API, Asynchronous, Push-based):

import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.Flow.*;

public class ReactiveExample {
    public static void main(String[] args) throws InterruptedException {
        SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();

        Subscriber<Integer> subscriber = new Subscriber<>() {
            private Subscription subscription;
            private int sum = 0;

            @Override
            public void onSubscribe(Subscription subscription) {
                this.subscription = subscription;
                subscription.request(1); // Request one item
            }

            @Override
            public void onNext(Integer item) {
                if (item % 2 == 0) {
                    sum += item;
                }
                subscription.request(1); // Request next item
            }

            @Override
            public void onError(Throwable throwable) {
                throwable.printStackTrace();
            }

            @Override
            public void onComplete() {
                System.out.println("Sum of even numbers: " + sum);
            }
        };

        publisher.subscribe(subscriber);

        // Publish numbers asynchronously
        for (int i = 1; i <= 5; i++) {
            publisher.submit(i);
        }
        publisher.close();

        Thread.sleep(100); // Give time for async processing
    }
}

Summary

Java Streams excel in simple, synchronous batch processing, while Reactive Streams provide powerful tools for asynchronous, event-driven, and scalable stream processing—especially suited to modern distributed and interactive systems.

19.3 Simple Examples Using Flow API (Java 9+)

Java 9 introduced the java.util.concurrent.Flow API to provide a standard interface for reactive streams. This API defines four key interfaces:

• Publisher : Produces items asynchronously.
• Subscriber : Consumes items, reacting to events.
• Subscription: Represents the link between Publisher and Subscriber, enabling backpressure.
• Processor<T, R>: Both a Subscriber and Publisher, acting as a data transformer.

Here, we'll focus on implementing a simple reactive stream pipeline by creating a custom Publisher and Subscriber and connecting them.

Basic Flow

1. Publisher sends data asynchronously.
2. Subscriber subscribes to Publisher and requests data.
3. Subscription controls the flow, allowing Subscriber to request or cancel.
4. Data and signals flow via onNext(), onError(), and onComplete() methods.

Example 1: StringPublisher and LoggingSubscriber

This minimal example demonstrates a publisher sending a fixed list of strings to a subscriber that logs received messages.

import java.util.List;
import java.util.concurrent.Flow.*;
import java.util.concurrent.SubmissionPublisher;

public class SimpleFlowExample {
    public static void main(String[] args) throws InterruptedException {
        // Publisher that asynchronously submits strings
        SubmissionPublisher<String> publisher = new SubmissionPublisher<>();

        // Subscriber that logs received items
        Subscriber<String> subscriber = new Subscriber<>() {
            private Subscription subscription;

            @Override
            public void onSubscribe(Subscription subscription) {
                this.subscription = subscription;
                subscription.request(1);  // Request the first item
            }

            @Override
            public void onNext(String item) {
                System.out.println("Received: " + item);
                subscription.request(1);  // Request next item after processing
            }

            @Override
            public void onError(Throwable throwable) {
                System.err.println("Error occurred: " + throwable.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("All items processed.");
            }
        };

        // Connect subscriber to publisher
        publisher.subscribe(subscriber);

        // Publish some items asynchronously
        List.of("Hello", "Reactive", "Streams", "with", "Flow API")
            .forEach(publisher::submit);

        // Close the publisher to signal end of stream
        publisher.close();

        // Wait briefly to allow async processing to complete
        Thread.sleep(1000);
    }
}

Explanation:

• SubmissionPublisher is a built-in Publisher that handles asynchronous submission.
• The Subscriber implements the 4 required methods.
• On onSubscribe(), the Subscriber requests one item.
• After receiving each item in onNext(), it processes and requests the next.
• onComplete() signals the stream has ended.
• The Thread.sleep() ensures the main thread waits for async processing.

Example 2: Custom Publisher and Subscriber

To understand internals, here is a minimal custom Publisher and Subscriber illustrating manual data flow control.

import java.util.concurrent.Flow.*;

public class ManualFlowExample {
    public static void main(String[] args) {
        Publisher<String> publisher = new Publisher<>() {
            @Override
            public void subscribe(Subscriber<? super String> subscriber) {
                subscriber.onSubscribe(new Subscription() {
                    private boolean completed = false;
                    @Override
                    public void request(long n) {
                        if (!completed) {
                            subscriber.onNext("Custom");
                            subscriber.onNext("Flow");
                            subscriber.onNext("Example");
                            subscriber.onComplete();
                            completed = true;
                        }
                    }
                    @Override
                    public void cancel() {
                        System.out.println("Subscription cancelled");
                    }
                });
            }
        };

        Subscriber<String> subscriber = new Subscriber<>() {
            private Subscription subscription;
            @Override
            public void onSubscribe(Subscription subscription) {
                this.subscription = subscription;
                subscription.request(1);
            }
            @Override
            public void onNext(String item) {
                System.out.println("Received: " + item);
                subscription.request(1);
            }
            @Override
            public void onError(Throwable throwable) {
                System.err.println("Error: " + throwable.getMessage());
            }
            @Override
            public void onComplete() {
                System.out.println("Processing complete.");
            }
        };

        publisher.subscribe(subscriber);
    }
}

Explanation:

• The custom Publisher calls subscriber.onSubscribe() with a Subscription implementation.
• The request(long n) method pushes predefined data items on demand.
• The Subscriber requests one item at a time, processing and then requesting the next.
• This shows explicit backpressure: the subscriber controls when it receives more data.

Summary

• The Flow API provides a simple but powerful abstraction for asynchronous, non-blocking stream processing.
• Publishers emit data asynchronously, Subscribers consume it, and Subscriptions manage flow control.
• SubmissionPublisher helps create async publishers with minimal code.
• Custom implementations offer flexibility for tailored reactive pipelines.

With these basics, you can build scalable reactive data flows integrated into modern Java applications.