Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Flow.Subscriber — recibir elementos con control de la demanda

Flow.Subscriber<T> recibe elementos y señales terminales de un publicador. Su suscripción permite expresar la demanda mediante request(n), de modo que el receptor controla cuántos elementos se entregan.

Versión: Java SE 21; repository runtime, production runtime not attested

Sintaxis

class Receiver<T> implements Flow.Subscriber<T> {
    public void onSubscribe(Flow.Subscription subscription) { }
    public void onNext(T item) { }
    public void onError(Throwable throwable) { }
    public void onComplete() { }
}

Flow.Subscriber<T> de java.util.concurrent es una interfaz receptora. T especifica el tipo de elemento. Las llamadas correspondientes a una misma Flow.Subscription son estrictamente secuenciales; esto no implica que estén vinculadas a un solo hilo.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) recibe la suscripción antes que los demás métodos. Guárdala y solicita elementos. Flow.Subscriber.onNext(T item) procesa un elemento. request(n) añade demanda en lugar de sustituir la anterior. En una suscripción activa, llamar a request(n) con n <= 0 genera una señal onError con IllegalArgumentException. Tras la cancelación de la suscripción o después de una señal terminal, llamar a request(n) no genera una nueva señal onError. Sin demanda no se entregan elementos. Este mecanismo es el control de flujo, o backpressure.

Flow.Subscriber.onError(Throwable throwable) señala un error irrecuperable, mientras que Flow.Subscriber.onComplete() señala la finalización normal. Ambas señales son terminales: después de cualquiera de ellas, la suscripción no invoca más métodos del receptor. No uses las excepciones lanzadas desde los métodos del receptor como protocolo de errores: la interfaz no garantiza que el comportamiento posterior sea correcto. cancel() se realiza con el mejor esfuerzo posible: aún pueden llegar mensajes y no se garantiza una señal terminal.

El ejemplo usa SubmissionPublisher y solicita otro elemento solo después de procesar el actual. close() termina la publicación, pero no sustituye la espera de la entrega; done.join() espera a que el receptor termine. El ejemplo muestra el flujo normal; un error completa done de forma excepcional.

Ejemplos

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

public class Main {
    static final class Receiver implements Flow.Subscriber<Integer> {
        private Flow.Subscription subscription;
        final CompletableFuture<Void> done = new CompletableFuture<>();

        @Override
        public void onSubscribe(Flow.Subscription subscription) {
            this.subscription = subscription;
            subscription.request(1);
        }

        @Override
        public void onNext(Integer item) {
            System.out.println("item=" + item);
            subscription.request(1);
        }

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

        @Override
        public void onComplete() {
            System.out.println("complete");
            done.complete(null);
        }
    }

    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        try (SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>()) {
            publisher.subscribe(receiver);
            publisher.submit(10);
            publisher.submit(20);
        }
        receiver.done.join();
    }
}

Resultado

item=10
item=20
complete

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes