Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Flow.Subscriber — odbieranie elementów z kontrolą zapotrzebowania

Flow.Subscriber<T> odbiera elementy i sygnały zakończenia od wydawcy. Subskrypcja pozwala zgłaszać zapotrzebowanie przez request(n), dzięki czemu odbiorca kontroluje liczbę dostarczanych elementów.

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

Składnia

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 jest interfejsem odbiorcy. T określa typ elementu. Dla jednej Flow.Subscription wywołania są ściśle sekwencyjne; nie oznacza to przypisania do jednego wątku.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) otrzymuje subskrypcję przed pozostałymi metodami. Zapisz ją i zgłoś zapotrzebowanie. Flow.Subscriber.onNext(T item) obsługuje pojedynczy element. request(n) dodaje zapotrzebowanie, zamiast zastępować poprzednie. W aktywnej subskrypcji wywołanie request(n) z n <= 0 powoduje sygnał onError z IllegalArgumentException. Po anulowaniu subskrypcji lub po sygnale terminalnym wywołanie request(n) nie powoduje nowego sygnału onError. Bez zapotrzebowania elementy nie są dostarczane. To mechanizm kontroli przepływu, czyli backpressure.

Flow.Subscriber.onError(Throwable throwable) sygnalizuje nieodwracalny błąd, a Flow.Subscriber.onComplete() — normalne zakończenie. Oba są terminalne: po jednym z nich subskrypcja nie wywołuje dalszych metod odbiorcy. Nie używaj wyjątków wyrzucanych z metod odbiorcy jako protokołu błędów: interfejs nie gwarantuje wtedy poprawnego dalszego działania. cancel() działa na zasadzie best effort: mogą jeszcze nadejść komunikaty i nie ma gwarancji sygnału terminalnego.

Przykład używa SubmissionPublisher i żąda kolejnego elementu dopiero po przetworzeniu bieżącego. close() kończy publikowanie, ale nie zastępuje oczekiwania na dostarczenie; done.join() czeka na zakończenie odbiorcy. Przykład pokazuje normalną ścieżkę; błąd kończy done wyjątkowo.

Przykłady

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

Wynik

item=10
item=20
complete

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła