WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Flow.Publisher – Elemente mit Bedarfssteuerung veröffentlichen

Flow.Publisher<T> beschreibt eine Quelle von Elementen, die Abonnenten empfangen. Die Methode subscribe verbindet einen Empfänger mit der Quelle; über Flow.Subscription kann er Elemente anfordern und den Empfang abbrechen.

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

Syntax

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

Flow.Publisher<T> ist ein funktionales Interface in java.util.concurrent. Flow.Publisher.subscribe hat die Signatur void subscribe(Flow.Subscriber<? super T> subscriber). Der Platzhalter ? super T akzeptiert einen Empfänger vom Typ T oder einem Supertyp. Ein akzeptierter Empfänger erhält onSubscribe mit einem Flow.Subscription-Objekt; ein null-Argument führt zu NullPointerException. Eine doppelte Anmeldung oder eine Ablehnung aufgrund einer Richtlinie oder eines Fehlers wird über onError mit IllegalStateException signalisiert.

Der Aufruf von subscribe allein erzeugt keinen Bedarf. request(n) erhöht den Bedarf um bis zu n weitere Elemente; bei n <= 0 wird onError mit IllegalArgumentException aufgerufen. Das ist Backpressure und keine Garantie, dass genau n Elemente geliefert werden. cancel() stoppt die Zustellung nach dem Best-Effort-Prinzip: Es können noch Nachrichten eintreffen, und ein Abschlusssignal ist nicht erforderlich.

Elemente werden über onNext geliefert; onComplete signalisiert den normalen Abschluss und onError einen Fehler. Nach einem Abschlusssignal erfolgen keine weiteren Aufrufe. Aufrufe innerhalb eines Abonnements sind durch happens-before geordnet. Gehe weder davon aus, dass frühere Elemente erneut abgespielt werden, noch von einer einheitlichen Strategie zum Verwerfen von Elementen: Beides hängt von der Implementierung ab.

Das Beispiel verwendet SubmissionPublisher als Implementierung und ruft subscribe über eine Referenz vom Typ Flow.Publisher<Integer> auf. Der Empfänger fordert zwei Elemente an. Das Schließen der Quelle leitet den normalen Abschluss ein; da die Zustellung asynchron erfolgt, hält CountDownLatch das Programm am Laufen, bis das Abschlusssignal verarbeitet wurde. Dieses Warten im Beispiel hat kein Zeitlimit; im Betrieb sollte der Umgang mit einem ausbleibenden Abschluss eingeplant werden.

Beispiele

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

Ergebnis

10
20
Done

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen