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

CKTIS / Java

Flow.Subscription — demanda y cancelación

Flow.Subscription controla la entrega de elementos entre un publicador y un suscriptor. request(long n) aumenta la demanda, mientras que cancel() pone fin a la recepción sin garantizar que la entrega se detenga de inmediato.

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

Sintaxis

import java.util.concurrent.Flow;

Flow.Subscription subscription;
// Interface methods:
void request(long n);
void cancel();

Flow.Subscription conecta un Flow.Publisher con un Flow.Subscriber. El suscriptor la recibe en onSubscribe, antes de las demás llamadas de retorno. Este mecanismo de control del flujo (backpressure) permite al receptor indicar cuántos elementos está preparado para aceptar; sin una solicitud, no recibe elementos mediante onNext.

Flow.Subscription.request(long n) añade n a la demanda pendiente, en lugar de sustituirla. Pueden llegar menos elementos si el flujo termina. Long.MAX_VALUE puede representar una demanda prácticamente ilimitada. Si la suscripción está activa, una llamada con n <= 0 notifica al suscriptor una IllegalArgumentException mediante onError, en lugar de que request lance la excepción de forma síncrona. Una vez cancelada la suscripción, request no tiene ningún efecto, ni siquiera con n <= 0.

Flow.Subscription.cancel() detiene la recepción según el mejor esfuerzo: todavía pueden llegar más mensajes. No garantiza ni onComplete ni onError. Ambos métodos están destinados únicamente al suscriptor asociado; cualquier otro uso tiene efectos indefinidos.

El ejemplo usa SubmissionPublisher con el ejecutor Runnable::run para entregar tareas en el hilo actual sin competir con la finalización del programa. El suscriptor solicita dos elementos y cancela tras el segundo. La salida esperada es 10 y 20, cada uno en una línea, sin complete. Es un ejemplo de Java SE 21, no una certificación de un entorno de producción.

Ejemplos

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

public class Main {
    public static void main(String[] args) {
        try (var publisher = new SubmissionPublisher<Integer>(Runnable::run, 4)) {
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                private Flow.Subscription subscription;
                private int received;

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

                @Override
                public void onNext(Integer item) {
                    System.out.println(item);
                    if (++received == 2) {
                        subscription.cancel();
                    }
                }

                @Override
                public void onError(Throwable error) {
                    System.out.println(error.getClass().getSimpleName());
                }

                @Override
                public void onComplete() {
                    System.out.println("complete");
                }
            });
            publisher.submit(10);
            publisher.submit(20);
            publisher.submit(30);
        }
    }
}

Resultado

10
20

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