Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Flow.Publisher — publikowanie elementów z kontrolą zapotrzebowania

Flow.Publisher<T> opisuje źródło elementów odbieranych przez subskrybentów. Metoda subscribe łączy odbiorcę ze źródłem, a Flow.Subscription pozwala zgłaszać zapotrzebowanie i anulować odbiór.

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

Składnia

Flow.Publisher<T>
void subscribe(Flow.Subscriber<? super T> subscriber)

Flow.Publisher<T> to interfejs funkcyjny w java.util.concurrent. Metoda Flow.Publisher.subscribe ma sygnaturę void subscribe(Flow.Subscriber<? super T> subscriber). Zapis ? super T dopuszcza odbiorcę typu T lub jego nadtypu. Przyjęty odbiorca otrzymuje onSubscribe z obiektem Flow.Subscription; argument null powoduje NullPointerException. Powtórna subskrypcja lub odrzucenie z powodu polityki bądź błędu jest sygnalizowane przez onError z IllegalStateException.

Samo subscribe nie zgłasza zapotrzebowania. request(n) dodaje zapotrzebowanie na maksymalnie n kolejnych elementów; n <= 0 powoduje onError z IllegalArgumentException. To mechanizm kontroli napływu danych (backpressure), a nie gwarancja dostarczenia dokładnie n elementów. cancel() zatrzymuje odbiór na zasadzie best-effort: mogą jeszcze nadejść wiadomości, a sygnał końcowy nie jest wymagany.

Elementy trafiają do onNext; onComplete oznacza normalny koniec, a onError — błąd. Po sygnale końcowym nie ma dalszych wywołań. Wywołania dla jednej subskrypcji są uporządkowane relacją happens-before. Nie zakładaj odtwarzania wcześniejszych elementów ani jednakowej polityki gubienia danych: zależą one od implementacji.

Przykład używa SubmissionPublisher jako implementacji i wywołuje subscribe przez referencję Flow.Publisher<Integer>. Odbiorca zamawia dwa elementy. Zamknięcie źródła inicjuje normalne zakończenie, ale dostarczanie jest asynchroniczne, więc CountDownLatch utrzymuje program do obsłużenia sygnału końcowego. To oczekiwanie demonstracyjne nie ma limitu czasu; w kodzie operacyjnym należy zaplanować obsługę braku zakończenia.

Przykłady

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch done = new CountDownLatch(1);
        try (SubmissionPublisher<Integer> source = new SubmissionPublisher<>()) {
            Flow.Publisher<Integer> publisher = source;
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                public void onSubscribe(Flow.Subscription subscription) {
                    subscription.request(2);
                }

                public void onNext(Integer item) {
                    System.out.println(item);
                }

                public void onError(Throwable error) {
                    System.out.println("Error: " + error.getClass().getSimpleName());
                    done.countDown();
                }

                public void onComplete() {
                    System.out.println("Done");
                    done.countDown();
                }
            });
            source.submit(10);
            source.submit(20);
        }
        done.await();
    }
}

Wynik

10
20
Done

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

Źródła