Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

Ugovori Java Flow: pretplata, potražnja i završetak

Nauči kako u Java SE 21 uspostaviti pretplatu Flow, primati elemente uz ograničenu potražnju i razlikovati uredan završetak, pogrešku i otkazivanje.

Verzija: 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();

U Java SE 21 tipovi Flow pripadaju paketu java.util.concurrent. Flow.Publisher<T>.subscribe prima Flow.Subscriber<? super T>, odnosno pretplatnika koji može obraditi T ili njegov nadtip. Nakon uspješne prijave izdavač predaje novu pretplatu metodi onSubscribe(Flow.Subscription) prije svih ostalih poziva za tu pretplatu. Prosljeđivanje null metodi subscribe uzrokuje bacanje iznimke NullPointerException. Ponovna prijava već prijavljenog pretplatnika ili odbijanje prijave prema pravilima izdavača prijavljuje se putem onError s iznimkom IllegalStateException.

Pretplatnik u onSubscribe sprema referencu i putem nje poziva request(long n). Pozitivni n dodaje se neispunjenoj potražnji, ne zamjenjuje je. Svaki onNext(T item) dostavlja jedan element i troši jednu jedinicu ograničene potražnje. Poziv request(1) nakon obrade elementa omogućuje primanje jednog po jednog elementa. Potražnja ograničava isporuku, a ne kapacitet izdavačeva međuspremnika. Long.MAX_VALUE može se smatrati praktično neograničenom potražnjom. U aktivnoj pretplati n <= 0 izaziva signal onError s iznimkom IllegalArgumentException; request ne baca tu iznimku sinkrono.

onComplete() označava uredan završetak, a onError(Throwable) nepopravljivu pogrešku. Ti signali ne troše potražnju za elementima. Međusobno se isključuju i nakon bilo kojeg od njih više nema poziva za tu pretplatu. Pozivi metoda pretplatnika za istu pretplatu uređeni su relacijom happens-before, ali se ne moraju izvoditi u istoj dretvi. Ne dopuštaj da se iznimke prošire iz tih metoda: ugovor ne jamči oporavak ni zasebnu obavijest putem onError.

cancel() utječe samo na tu pretplatu. Zaustavlja isporuku koliko je moguće, ali ne nužno odmah: signali koji su već na putu još mogu stići. Otkazivanje nije uredan završetak; nakon njega ne čekaj onComplete() ni onError(Throwable). Primjer implementira pretplatnika, a upravljanje pretplatom i isporuku prepušta klasi SubmissionPublisher iz biblioteke.

Primjeri

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

U slučaju `COMPLETE` pretplatnik zatraži jedan element, nakon `10` zatraži još jedan, a nakon `20` primi `onComplete`. U slučaju `INVALID` poziv `request(0)` izaziva `onError` bez objave elemenata. U slučaju `CANCEL` pretplatnik otkazuje nakon jedinog objavljenog elementa. Program čeka očekivani događaj umjesto fiksne pauze: `close()` ne čeka završetak svih poziva metoda pretplatnika, a pri otkazivanju program ne čeka završni signal.

Povezane lekcije

  • Java · Lekcija 44 · Napredno · Verzija: 2

Izvori