WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Flow.Subscriber — Elemente mit Bedarfskontrolle empfangen

Flow.Subscriber<T> empfängt Elemente und Abschlusssignale von einem Publisher. Über das Abonnement kann der Subscriber mit request(n) Bedarf anmelden und so steuern, wie viele Elemente zugestellt werden.

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

Syntax

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> aus java.util.concurrent ist eine Empfängerschnittstelle. T legt den Elementtyp fest. Aufrufe für ein und dasselbe Flow.Subscription erfolgen streng sequenziell; das bedeutet nicht, dass sie an einen einzelnen Thread gebunden sind.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) erhält das Abonnement vor den übrigen Methoden. Speichere es und fordere Elemente an. Flow.Subscriber.onNext(T item) verarbeitet ein einzelnes Element. request(n) erhöht den Bedarf, statt den vorherigen Bedarf zu ersetzen. Bei einem aktiven Abonnement löst ein Aufruf von request(n) mit n <= 0 ein onError-Signal mit IllegalArgumentException aus. Nach der Kündigung des Abonnements oder nach einem terminalen Signal löst ein Aufruf von request(n) kein neues onError-Signal aus. Ohne angemeldeten Bedarf werden keine Elemente zugestellt. Das ist Flusskontrolle, auch Backpressure genannt.

Flow.Subscriber.onError(Throwable throwable) signalisiert einen nicht behebbaren Fehler, während Flow.Subscriber.onComplete() den normalen Abschluss signalisiert. Beide sind terminal: Nach einem von ihnen ruft das Abonnement keine weiteren Methoden des Empfängers auf. Verwende Ausnahmen, die aus Empfängermethoden ausgelöst werden, nicht als Fehlerprotokoll: Die Schnittstelle garantiert dann kein korrektes weiteres Verhalten. cancel() erfolgt nach bestem Bemühen: Es können weiterhin Nachrichten eintreffen, und ein terminales Signal ist nicht garantiert.

Das Beispiel verwendet SubmissionPublisher und fordert das nächste Element erst an, nachdem das aktuelle verarbeitet wurde. close() beendet das Veröffentlichen, ersetzt aber nicht das Warten auf die Zustellung; done.join() wartet, bis der Empfänger fertig ist. Das Beispiel zeigt den normalen Ablauf; bei einem Fehler wird done außergewöhnlich abgeschlossen.

Beispiele

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

Ergebnis

item=10
item=20
complete

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