Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Flow.Subscriber — příjem položek s řízením poptávky

Flow.Subscriber<T> přijímá položky a koncové signály od vydavatele. Pomocí subscription může vyjádřit poptávku voláním request(n), a řídit tak počet doručených položek.

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

Syntaxe

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> z java.util.concurrent je rozhraní příjemce. T určuje typ položky. Volání pro jednu Flow.Subscription probíhají striktně sekvenčně; neznamená to, že jsou vázána na jedno vlákno.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) obdrží subscription před ostatními metodami. Uložte si ji a vyžádejte položky. Flow.Subscriber.onNext(T item) zpracuje jednu položku. request(n) přidává poptávku, místo aby nahrazovalo předchozí. U aktivní subscription vyvolá volání request(n) s n <= 0 signál onError s IllegalArgumentException. Po zrušení subscription nebo po terminálním signálu už volání request(n) nevyvolá nový signál onError. Bez poptávky se položky nedoručují. Jde o řízení toku neboli backpressure.

Flow.Subscriber.onError(Throwable throwable) signalizuje neobnovitelnou chybu, zatímco Flow.Subscriber.onComplete() signalizuje normální dokončení. Oba signály jsou terminální: po kterémkoli z nich už subscription nevolá další metody příjemce. Výjimky vyhozené z metod příjemce nepoužívejte jako chybový protokol: rozhraní pak nezaručuje správné další chování. cancel() funguje podle nejlepšího úsilí: zprávy mohou stále dorazit a terminální signál není zaručen.

Příklad používá SubmissionPublisher a další položku vyžádá až po zpracování aktuální položky. close() ukončí publikování, ale nenahrazuje čekání na doručení; done.join() čeká na dokončení příjemce. Příklad ukazuje běžný průběh; při chybě se done dokončí výjimečně.

Příklady

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

Výsledek

item=10
item=20
complete

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje