Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Flow.Subscriber — ricevere elementi controllando la domanda

Flow.Subscriber<T> riceve elementi e segnali terminali da un publisher. La subscription permette di esprimere la domanda tramite request(n), così il ricevente controlla quanti elementi vengono consegnati.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

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> di java.util.concurrent è un’interfaccia ricevente. T specifica il tipo di elemento. Le chiamate relative a una stessa Flow.Subscription sono strettamente sequenziali; ciò non implica che siano associate a un unico thread.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) riceve la subscription prima degli altri metodi. Conservala e richiedi gli elementi. Flow.Subscriber.onNext(T item) gestisce un singolo elemento. request(n) aggiunge domanda invece di sostituire quella precedente. Su una subscription attiva, chiamare request(n) con n <= 0 genera un segnale onError con IllegalArgumentException. Dopo l’annullamento della subscription o dopo un segnale terminale, chiamare request(n) non genera un nuovo segnale onError. Senza domanda gli elementi non vengono consegnati. Questo è il controllo del flusso, o backpressure.

Flow.Subscriber.onError(Throwable throwable) segnala un errore irrecuperabile, mentre Flow.Subscriber.onComplete() segnala il completamento normale. Entrambi sono terminali: dopo l’uno o l’altro, la subscription non invoca altri metodi del ricevente. Non usare le eccezioni lanciate dai metodi del ricevente come protocollo di errore: l’interfaccia non garantisce che il comportamento successivo sia corretto. cancel() opera al meglio: possono comunque arrivare messaggi e non è garantito un segnale terminale.

L’esempio usa SubmissionPublisher e richiede un altro elemento solo dopo aver elaborato quello corrente. close() termina la pubblicazione, ma non sostituisce l’attesa della consegna; done.join() aspetta che il ricevente termini. L’esempio mostra il percorso normale; un errore completa done in modo eccezionale.

Esempi

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();
    }
}

Risultato

item=10
item=20
complete

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti