KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Flow.Subscriber — elementen ontvangen met vraagcontrole

Flow.Subscriber<T> ontvangt elementen en eindsignalen van een publisher. Met de subscription kan de ontvanger via request(n) vraag aangeven en zo bepalen hoeveel elementen worden geleverd.

Versie: 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> uit java.util.concurrent is een ontvangende interface. T geeft het elementtype aan. Aanroepen voor één Flow.Subscription verlopen strikt sequentieel; dat betekent niet dat ze aan één thread zijn gebonden.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) ontvangt de subscription vóór de andere methoden. Bewaar deze en vraag elementen aan. Flow.Subscriber.onNext(T item) verwerkt één element. request(n) voegt vraag toe in plaats van eerdere vraag te vervangen. Bij een actieve subscription leidt een aanroep van request(n) met n <= 0 tot een onError-signaal met IllegalArgumentException. Na annulering van de subscription of na een eindsignaal leidt een aanroep van request(n) niet tot een nieuw onError-signaal. Zonder vraag worden geen elementen geleverd. Dit is flow control, oftewel backpressure.

Flow.Subscriber.onError(Throwable throwable) geeft een onherstelbare fout aan, terwijl Flow.Subscriber.onComplete() normale voltooiing aangeeft. Beide zijn terminaal: na een van beide roept de subscription geen verdere methoden van de ontvanger aan. Gebruik uitzonderingen die uit ontvangermethoden worden gegooid niet als foutprotocol: de interface garandeert dan geen correct vervolg. cancel() werkt naar beste vermogen: er kunnen nog berichten aankomen en een terminaal signaal is niet gegarandeerd.

Het voorbeeld gebruikt SubmissionPublisher en vraagt pas een volgend element aan nadat het huidige is verwerkt. close() beëindigt het publiceren, maar vervangt het wachten op levering niet; done.join() wacht tot de ontvanger klaar is. Het voorbeeld toont het normale verloop; bij een fout wordt done uitzonderlijk voltooid.

Voorbeelden

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

Resultaat

item=10
item=20
complete

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen