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

CKTIS / Java

Pogodbe Java Flow: naročnina, povpraševanje in zaključek

Nauči se vzpostaviti naročnino Flow v Java SE 21, prejemati elemente z omejenim povpraševanjem ter razlikovati običajni zaključek, napako in preklic.

Različica: Java SE 21

Sintaksa

import java.util.concurrent.Flow;

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

// Flow.Subscriber<T>
void onSubscribe(Flow.Subscription subscription);
void onNext(T item);
void onError(Throwable error);
void onComplete();

// Flow.Subscription
void request(long n);
void cancel();

V Java SE 21 so tipi Flow v paketu java.util.concurrent. Flow.Publisher<T>.subscribe sprejme Flow.Subscriber<? super T>, torej naročnika, ki zna obdelati T ali njegov nadtip. Ob uspešni prijavi izdajatelj preda novo naročnino metodi onSubscribe(Flow.Subscription) pred vsemi drugimi klici za to naročnino. Če metodi subscribe podaš null, ta sproži NullPointerException. Podvojena prijava že prijavljenega naročnika ali zavrnitev zaradi pravil izdajatelja se sporoči prek onError z izjemo IllegalStateException.

Naročnik v onSubscribe shrani referenco in prek nje kliče request(long n). Pozitivni n se prišteje k še neizpolnjenemu povpraševanju in ga ne nadomesti. Vsak onNext(T item) dostavi en element in porabi eno enoto omejenega povpraševanja. Če po obdelavi elementa pokličeš request(1), lahko elemente prejemaš posamično. Povpraševanje omejuje dostavo, ne zmogljivosti izdajateljevega medpomnilnika. Long.MAX_VALUE se lahko obravnava kot praktično neomejeno povpraševanje. Pri aktivni naročnini n <= 0 povzroči signal onError z izjemo IllegalArgumentException, ki je request ne sproži sinhrono.

onComplete() označuje običajni zaključek, onError(Throwable) pa nepopravljivo napako. Signala ne porabljata povpraševanja po elementih. Izključujeta se in po enem ali drugem za to naročnino ni več klicev. Klici naročnikovih metod za isto naročnino so urejeni z relacijo happens-before, vendar ni nujno, da tečejo v isti niti. Ne dovoli, da se izjeme širijo iz teh metod: pogodba ne zagotavlja obnovitve delovanja ali ločenega obvestila prek onError.

cancel() vpliva le na zadevno naročnino. Dostavo ustavi, kolikor je mogoče, vendar ne nujno takoj: signali, ki so že na poti, lahko še prispejo. Preklic ni običajni zaključek; po njem ne čakaj na onComplete() ali onError(Throwable). Primer implementira naročnika, upravljanje naročnine in dostavo pa prepusti knjižničnemu razredu SubmissionPublisher.

Primeri

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Flow;
import java.util.concurrent.SubmissionPublisher;
import java.util.concurrent.TimeUnit;

public class FlowContractsDemo {
    private enum Mode { COMPLETE, INVALID, CANCEL }

    public static void main(String[] args) throws Exception {
        try (ExecutorService executor = Executors.newSingleThreadExecutor()) {
            for (Mode mode : Mode.values()) {
                run(executor, mode);
            }
        }
    }

    private static void run(ExecutorService executor, Mode mode) throws Exception {
        System.out.println(mode);
        var done = new CompletableFuture<Void>();
        try (var publisher = new SubmissionPublisher<Integer>(executor, 8)) {
            publisher.subscribe(new Flow.Subscriber<Integer>() {
                private Flow.Subscription subscription;

                @Override
                public void onSubscribe(Flow.Subscription subscription) {
                    this.subscription = subscription;
                    System.out.println("onSubscribe");
                    subscription.request(mode == Mode.INVALID ? 0L : 1L);
                }

                @Override
                public void onNext(Integer item) {
                    System.out.println("onNext " + item);
                    if (mode == Mode.CANCEL) {
                        subscription.cancel();
                        System.out.println("cancel");
                        done.complete(null);
                    } else if (mode == Mode.COMPLETE && item == 10) {
                        subscription.request(1L);
                    }
                }

                @Override
                public void onError(Throwable error) {
                    if (mode == Mode.INVALID && error instanceof IllegalArgumentException) {
                        System.out.println("onError IllegalArgumentException");
                        done.complete(null);
                    } else {
                        done.completeExceptionally(error);
                    }
                }

                @Override
                public void onComplete() {
                    if (mode == Mode.COMPLETE) {
                        System.out.println("onComplete");
                        done.complete(null);
                    } else {
                        done.completeExceptionally(new IllegalStateException("Unexpected completion"));
                    }
                }
            });

            if (mode != Mode.INVALID) {
                publisher.submit(10);
            }
            if (mode == Mode.COMPLETE) {
                publisher.submit(20);
                publisher.close();
            }
            done.get(10, TimeUnit.SECONDS);
        }
    }
}

Rezultat

COMPLETE
onSubscribe
onNext 10
onNext 20
onComplete
INVALID
onSubscribe
onError IllegalArgumentException
CANCEL
onSubscribe
onNext 10
cancel

V `COMPLETE` naročnik zahteva en element, po `10` zahteva še enega in po `20` prejme `onComplete`. V `INVALID` klic `request(0)` povzroči `onError`, ne da bi bil objavljen kakšen element. V `CANCEL` naročnik prekliče naročnino po edinem objavljenem elementu. Program počaka na pričakovani dogodek namesto na iztek stalne zakasnitve: `close()` ne čaka na konec vseh klicev naročnikovih metod, pri preklicu pa program ne čaka na zaključni signal.

Povezane lekcije

  • Java · Lekcija 44 · Napredna · Različica: 2

Viri