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

CKTIS / Java

CompletableFuture: композиране, срокове и изпълнители

Композирайте етапи в Java SE 21, възстановявайте се от грешки, координирайте няколко обекта future и избирайте изрично изпълнители за асинхронни задачи.

Версия: Java SE 21

Синтаксис

import java.util.concurrent.CompletableFuture;

CompletableFuture.completedFuture(value)
future.thenApply(value -> mappedValue)
future.thenCompose(value -> nextStage)
future.thenCombine(otherStage, (left, right) -> combinedValue)
future.completeExceptionally(cause)
future.exceptionally(cause -> fallbackValue)
CompletableFuture.allOf(future1, future2)
CompletableFuture.anyOf(future1, future2)
future.completeOnTimeout(fallbackValue, timeout, unit)
future.orTimeout(timeout, unit)
CompletableFuture.supplyAsync(() -> value)
CompletableFuture.supplyAsync(() -> value, io)
future.thenApplyAsync(value -> mappedValue)
future.thenApplyAsync(value -> mappedValue, cpu)
future.join()

CompletableFuture е част от java.util.concurrent. Статичният метод completedFuture(value) създава вече успешно завършен обект future. thenApply преобразува успешния резултат в стойност в нов етап. Използвайте thenCompose, ако функцията връща CompletionStage: новият етап следва изхода на върнатия етап, вместо да съдържа самия етап като стойност. thenCombine извиква функцията с двата резултата само ако и двата етапа завършат успешно; не стартира нито един от тях.

completeExceptionally(cause) завършва същия обект future с изключение и връща true само ако точно това извикване го е завършило. exceptionally създава нов етап, който предава успешния резултат или изчислява резервна стойност от изключението. join() блокира при нужда и връща резултата, хвърля непроверявано изключение CompletionException при грешка или хвърля CancellationException, ако обектът future е отменен. Предпочитайте да извиквате join() на границата на програмата, вместо да блокирате работни нишки във веригата.

Статичният метод allOf връща CompletableFuture<Void>, който изчаква всички входни обекти да завършат, дори някой да завърши с грешка. При грешка на който и да е вход общият обект също завършва с грешка и не събира стойности. След успех прочетете стойностите поотделно. Без входове обектът вече е завършен със стойност null. Статичният метод anyOf връща CompletableFuture<Object>, който завършва с резултата или изключението на един от входовете, когато се установи, че този вход е завършил. Ако при извикването вече са завършили няколко входа, API не гарантира, че ще бъде избран този, който е завършил най-рано. Не чака първия успех и не отменя останалите входове. Без входове остава незавършен.

Ако обектът future все още не е завършен при изтичане на срока, completeOnTimeout(value, timeout, unit) го завършва успешно с резервна стойност, а orTimeout(timeout, unit) го завършва с TimeoutException. И двата метода са налични от Java 9. Те настройват и връщат същия обект, не променят вече установения изход и не прекъсват изчислението. Срокът се отнася до завършването на обекта future, а не само до изчакването от извикващия join().

supplyAsync(supplier, io) стартира функцията, която предоставя стойността, чрез io, а thenApplyAsync(fn, cpu) след успех изпълнява преобразуването чрез cpu. Следващите етапи не наследяват тези изпълнители. Без изричен Executor стандартният CompletableFuture използва ForkJoinPool.commonPool() или нова нишка за всяка задача, ако пулът не поддържа паралелизъм поне две. Подкласовете могат да променят изпълнителя по подразбиране за методите на екземпляра. Методите без Async, например thenCombine, не гарантират конкретен изпълнител или нишка и могат да се изпълнят непосредствено, ако входовете са готови. За да изберете изпълнител за комбинирането, използвайте thenCombineAsync(other, fn, executor).

Примери

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        var composed = CompletableFuture.completedFuture(2)
                .thenApply(n -> n + 1)
                .thenCompose(n -> CompletableFuture.completedFuture(n * 2))
                .thenCombine(CompletableFuture.completedFuture(4), Integer::sum);
        System.out.println("composed=" + composed.join());

        var failed = new CompletableFuture<Integer>();
        failed.completeExceptionally(new IllegalStateException("unavailable"));
        System.out.println("recovered=" + failed.exceptionally(error -> -1).join());

        var ready = CompletableFuture.completedFuture("ready");
        var pending = new CompletableFuture<String>();
        System.out.println("any=" + CompletableFuture.anyOf(ready, pending).join());
        var all = CompletableFuture.allOf(ready, pending);
        pending.complete("done");
        all.join();
        System.out.println("all=" + ready.join() + "," + pending.join());

        var fallback = new CompletableFuture<Integer>();
        var same = fallback.completeOnTimeout(0, 10, TimeUnit.MILLISECONDS);
        System.out.println("fallback=" + same.join() + ", same=" + (same == fallback));
        var deadline = new CompletableFuture<Integer>();
        try {
            deadline.orTimeout(10, TimeUnit.MILLISECONDS).join();
        } catch (CompletionException error) {
            System.out.println("timeout=" + error.getCause().getClass().getSimpleName());
        }

        try (var io = Executors.newSingleThreadExecutor();
             var cpu = Executors.newSingleThreadExecutor()) {
            var loaded = CompletableFuture.supplyAsync(() -> 7, io);
            var offset = CompletableFuture.supplyAsync(() -> 3, io);
            var total = loaded.thenApplyAsync(n -> n * 2, cpu)
                    .thenCombine(offset, Integer::sum);
            System.out.println("async=" + total.join());
        }
    }
}

Резултат

composed=10
recovered=-1
any=ready
all=ready,done
fallback=0, same=true
timeout=TimeoutException
async=17

Повечето етапи в първата композиция използват вече налични резултати. Няма задачи, които да завършат обектите future със срок, затова изходът не зависи от надпревара с изчисление. `io` и `cpu` са отделни демонстрационни изпълнители; try-with-resources затваря и двата. Не приемайте, че `thenCombine` ще се изпълни в определена нишка или след точно определено време.

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

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

Източници