KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Flow.Subscription — vraag en annulering

Flow.Subscription regelt de levering van elementen tussen een publisher en een subscriber. request(long n) verhoogt de vraag, terwijl cancel() de ontvangst beëindigt zonder te garanderen dat de levering meteen stopt.

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

Syntax

import java.util.concurrent.Flow;

Flow.Subscription subscription;
// Interface methods:
void request(long n);
void cancel();

Flow.Subscription verbindt een Flow.Publisher met een Flow.Subscriber. De subscriber ontvangt deze in onSubscribe, vóór de overige callbacks. Met dit mechanisme voor stroomregeling (backpressure) kan de ontvanger aangeven hoeveel elementen deze wil accepteren; zonder verzoek ontvangt de subscriber geen elementen via onNext.

Flow.Subscription.request(long n) telt n op bij de openstaande vraag, in plaats van deze te vervangen. Er kunnen minder elementen aankomen als de stroom eindigt. Long.MAX_VALUE kan een praktisch onbeperkte vraag betekenen. Bij een actief abonnement wordt een IllegalArgumentException bij n <= 0 via onError aan de subscriber gemeld; request werpt de uitzondering niet synchroon op. Na annulering van het abonnement heeft request geen effect, ook niet bij n <= 0.

Flow.Subscription.cancel() stopt de ontvangst zo goed mogelijk: er kunnen nog berichten aankomen. Dit garandeert noch onComplete noch onError. Beide methoden zijn uitsluitend bedoeld voor de bijbehorende subscriber; ander gebruik heeft ongedefinieerde gevolgen.

Het voorbeeld gebruikt SubmissionPublisher met de executor Runnable::run om taken in de huidige thread af te leveren zonder een race met het beëindigen van het programma. De subscriber vraagt twee elementen aan en annuleert na het tweede. De verwachte uitvoer is 10 en 20, elk op een eigen regel, zonder complete. Dit is een voorbeeld voor Java SE 21, geen bevestiging van een productieomgeving.

Voorbeelden

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

public class Main {
    public static void main(String[] args) {
        try (var publisher = new SubmissionPublisher<Integer>(Runnable::run, 4)) {
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                private Flow.Subscription subscription;
                private int received;

                @Override
                public void onSubscribe(Flow.Subscription s) {
                    subscription = s;
                    subscription.request(2);
                }

                @Override
                public void onNext(Integer item) {
                    System.out.println(item);
                    if (++received == 2) {
                        subscription.cancel();
                    }
                }

                @Override
                public void onError(Throwable error) {
                    System.out.println(error.getClass().getSimpleName());
                }

                @Override
                public void onComplete() {
                    System.out.println("complete");
                }
            });
            publisher.submit(10);
            publisher.submit(20);
            publisher.submit(30);
        }
    }
}

Resultaat

10
20

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