Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Flow.Publisher: pubblicare elementi con controllo della domanda

Flow.Publisher<T> descrive una sorgente di elementi ricevuti dai sottoscrittori. Il metodo subscribe collega un destinatario alla sorgente, mentre Flow.Subscription permette di richiedere elementi e annullare la ricezione.

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

Sintassi

Flow.Publisher<T>
void subscribe(Flow.Subscriber<? super T> subscriber)

Flow.Publisher<T> è un’interfaccia funzionale in java.util.concurrent. Flow.Publisher.subscribe ha la firma void subscribe(Flow.Subscriber<? super T> subscriber). Il carattere jolly ? super T accetta un destinatario di tipo T o di un supertipo. Un destinatario accettato riceve onSubscribe con un oggetto Flow.Subscription; un argomento null causa NullPointerException. Una sottoscrizione duplicata o un rifiuto dovuto a una policy o a un errore viene segnalato tramite onError con IllegalStateException.

La sola chiamata a subscribe non crea domanda. request(n) aggiunge domanda per un massimo di n elementi successivi; se n <= 0, viene chiamato onError con IllegalArgumentException. È backpressure, non una garanzia di ricevere esattamente n elementi. cancel() interrompe la ricezione secondo il principio del miglior sforzo: possono ancora arrivare messaggi e non è richiesto un segnale terminale.

Gli elementi arrivano tramite onNext; onComplete indica la conclusione normale e onError un errore. Dopo un segnale terminale non seguono altre chiamate. Le chiamate di una singola sottoscrizione sono ordinate dalla relazione happens-before. Non dare per scontati né la riproduzione degli elementi precedenti né una politica uniforme di scarto: dipendono dall’implementazione.

L’esempio usa SubmissionPublisher come implementazione e chiama subscribe tramite un riferimento Flow.Publisher<Integer>. Il destinatario richiede due elementi. La chiusura della sorgente avvia la conclusione normale, ma la consegna è asincrona, quindi CountDownLatch mantiene in esecuzione il programma finché il segnale terminale non viene gestito. Questa attesa dimostrativa non ha un limite di tempo; nel codice operativo occorre prevedere come gestire la mancata conclusione.

Esempi

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch done = new CountDownLatch(1);
        try (SubmissionPublisher<Integer> source = new SubmissionPublisher<>()) {
            Flow.Publisher<Integer> publisher = source;
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                public void onSubscribe(Flow.Subscription subscription) {
                    subscription.request(2);
                }

                public void onNext(Integer item) {
                    System.out.println(item);
                }

                public void onError(Throwable error) {
                    System.out.println("Error: " + error.getClass().getSimpleName());
                    done.countDown();
                }

                public void onComplete() {
                    System.out.println("Done");
                    done.countDown();
                }
            });
            source.submit(10);
            source.submit(20);
        }
        done.await();
    }
}

Risultato

10
20
Done

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