Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / Java

Flow.Subscriber — prejemanje elementov z nadzorom povpraševanja

Flow.Subscriber<T> prejema elemente in zaključne signale od izdajatelja. Z naročnino lahko izrazi povpraševanje z request(n) in tako nadzoruje, koliko elementov bo dostavljenih.

Različica: Java SE 21; repository runtime, production runtime not attested

Sintaksa

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> iz java.util.concurrent je vmesnik prejemnika. T določa vrsto elementa. Klici za isto Flow.Subscription potekajo strogo zaporedno; to ne pomeni, da so vezani na eno nit.

Flow.Subscriber.onSubscribe(Flow.Subscription subscription) prejme naročnino pred drugimi metodami. Shranite jo in zahtevajte elemente. Flow.Subscriber.onNext(T item) obdela en element. request(n) poveča povpraševanje, namesto da bi nadomestil prejšnje. Pri aktivni naročnini klic request(n) z n <= 0 sproži signal onError z IllegalArgumentException. Po preklicu naročnine ali po končnem signalu klic request(n) ne sproži novega signala onError. Brez povpraševanja se elementi ne dostavljajo. To je nadzor pretoka oziroma backpressure.

Flow.Subscriber.onError(Throwable throwable) sporoči nepopravljivo napako, Flow.Subscriber.onComplete() pa običajen zaključek. Oba signala sta končna: po katerem koli od njiju naročnina ne kliče več metod prejemnika. Izjem, vrženih iz metod prejemnika, ne uporabljajte kot protokol za napake: vmesnik v tem primeru ne zagotavlja pravilnega nadaljnjega delovanja. cancel() deluje po najboljših močeh: sporočila lahko še vedno prispejo, končni signal pa ni zagotovljen.

Primer uporablja SubmissionPublisher in naslednji element zahteva šele, ko obdela trenutnega. close() konča objavljanje, vendar ne nadomesti čakanja na dostavo; done.join() počaka, da se prejemnik konča. Primer prikazuje običajen potek; napaka zaključi done izjemoma.

Primeri

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

Rezultat

item=10
item=20
complete

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri