База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / Java

Договори в Java Flow: абонамент, заявки и приключване

Научи как в Java SE 21 да установиш абонамент във Flow, да получаваш ограничен брой заявени елементи и да различаваш нормално приключване, грешка и отмяна.

Версия: Java SE 21

Синтаксис

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

В Java SE 21 типовете Flow са в пакета java.util.concurrent. Flow.Publisher<T>.subscribe приема Flow.Subscriber<? super T> — абонат, който може да обработва T или негов надтип. При успешна регистрация издателят предава нов абонамент на onSubscribe(Flow.Subscription), преди каквото и да е друго извикване за този абонамент. Подаването на null на subscribe води до хвърляне на NullPointerException. Повторна регистрация на вече абониран получател или отказ за регистрация според правилата на издателя се съобщава чрез onError с IllegalStateException.

Абонатът запазва референцията в onSubscribe и чрез нея извиква request(long n). Положителното n се прибавя към броя на заявените, но още неполучени елементи, вместо да го замени. Всяко onNext(T item) доставя един елемент и намалява ограничения брой оставащи заявки с единица. Извикването на request(1) след обработка на елемент позволява получаване на елементите един по един. Заявките ограничават доставката, а не капацитета на буфера на издателя. Long.MAX_VALUE може да се третира като практически неограничена заявка. При активен абонамент n <= 0 води до сигнал onError с IllegalArgumentException, а не до синхронно хвърляне на изключението от request.

onComplete() сигнализира нормално приключване, а onError(Throwable) — непоправима грешка. Тези сигнали не намаляват броя на оставащите заявени елементи. Те взаимно се изключват и след който и да е от тях няма други извиквания за този абонамент. Извикванията към абоната за даден абонамент са подредени чрез релацията happens-before, но не е нужно да се изпълняват в една и съща нишка. Не допускай изключения да напускат тези методи: договорът не гарантира възстановяване или отделно известие чрез onError.

cancel() засяга само конкретния абонамент. Доставката спира, доколкото е възможно, но не непременно веднага: сигнали, които вече са в процес на доставка, може все още да пристигнат. Отмяната не е нормално приключване; не чакай onComplete() или onError(Throwable) след нея. Примерът реализира абонат и оставя управлението на абонамента и доставката на библиотечния клас SubmissionPublisher.

Примери

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

Резултат

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

В `COMPLETE` абонатът заявява един елемент, след `10` заявява още един и след `20` получава `onComplete`. В `INVALID` извикването на `request(0)` води до `onError`, без да се публикуват елементи. В `CANCEL` абонатът отменя абонамента след единствения публикуван елемент. Програмата изчаква очакваното събитие вместо фиксирана пауза: `close()` не изчаква приключването на всички извиквания към абонатите, а при отмяна програмата не чака краен сигнал.

Свързани уроци

  • Java · Урок 44 · Напреднало · Версия: 2

Източници