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

CKTIS / Java

Flow.Subscription — požadavek a zrušení

Flow.Subscription řídí předávání položek mezi vydavatelem a odběratelem. request(long n) zvyšuje požadavek, zatímco cancel() ukončí příjem, aniž by zaručovalo, že se předávání okamžitě zastaví.

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

Syntaxe

import java.util.concurrent.Flow;

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

Flow.Subscription propojuje Flow.Publisher s Flow.Subscriber. Odběratel ji obdrží v onSubscribe před ostatními zpětnými voláními. Tento mechanismus řízení toku (backpressure) umožňuje příjemci určit, kolik položek je připraven přijmout; bez požadavku nedostane přes onNext žádné položky.

Flow.Subscription.request(long n) přičítá n k dosud nevyřízenému požadavku, místo aby jej nahradilo. Pokud tok skončí, může dorazit méně položek. Long.MAX_VALUE může znamenat prakticky neomezený požadavek. Pokud je odběr aktivní, při volání s n <= 0 dostane odběratel výjimku IllegalArgumentException prostřednictvím onError; metoda request ji nevyhodí synchronně. Po zrušení odběru nemá volání request žádný účinek, ani pro n <= 0.

Flow.Subscription.cancel() zastaví příjem v rámci nejlepších možností: další zprávy mohou přesto dorazit. Nezaručuje ani onComplete, ani onError. Obě metody jsou určeny pouze přidruženému odběrateli; jiné použití má nedefinované účinky.

Příklad používá SubmissionPublisher s executorem Runnable::run, který doručuje úlohy v aktuálním vlákně, takže nedochází k závodu s ukončením programu. Odběratel požádá o dvě položky a po druhé zruší odběr. Očekávaný výstup je 10 a 20, každý na samostatném řádku, bez complete. Jde o příklad pro Java SE 21, nikoli o potvrzení produkčního prostředí.

Příklady

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

Výsledek

10
20

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