Асинхронность в Java: Future, CompletableFuture и Structured Concurrency

Java изначально была ориентирована на многопоточность и параллельные вычисления. Со временем появились разные способы работы с результатами асинхронных задач — от классического Future до современных Structured Concurrency. Разберём основные механизмы, их плюсы, минусы и когда их использовать.

1. Future<T> (Java 5)

Описание: Future<T> — это интерфейс, представляющий результат асинхронной задачи, который будет готов в будущем.

Основные методы:

• get() — блокирует поток до завершения задачи и возвращает результат.
• cancel() — пытается отменить задачу.
• isDone() — проверяет, завершена ли задача.
• isCancelled() — проверяет, была ли задача отменена.

Плюсы: простой способ получить результат асинхронной задачи; интегрируется с ExecutorService.

Минусы: блокирующий метод get(), нет встроенной поддержки цепочек или комбинирования задач, ручное управление потоками и исключениями.

ExecutorService executor = Executors.newFixedThreadPool(2);
Future<String> future = executor.submit(() -> "Hello Future");
System.out.println(future.get());
executor.shutdown();

Схема:

[Main Thread] ---calls---> [Future.get()]
                         |
                         v
                    [Worker Thread]
                         |
                         v
                      Result

Main Thread блокируется, пока Worker Thread выполняет задачу.

2. CompletableFuture<T> (Java 8)

Описание: CompletableFuture расширяет Future и добавляет неблокирующие цепочки, обработку ошибок и комбинирование нескольких задач.

Плюсы: асинхронные цепочки (thenApply, thenCompose, thenAccept), лёгкое объединение нескольких задач (allOf, anyOf), неблокирующее выполнение.

Минусы: требует понимания цепочек и колбэков, сложнее отлаживать при длинных цепочках задач.

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")
    .thenAccept(System.out::println);

Схема:

[supplyAsync] --> [thenApply] --> [thenAccept]
     |               |                |
 Worker Thread     Worker Thread   Worker Thread

Main Thread не блокируется.
Каждая стадия может выполняться в другом потоке.
Можно объединять несколько цепочек (thenCombine, allOf, anyOf).

3. Structured Concurrency (Java 19+)

Описание: Structured Concurrency API позволяет объединять несколько асинхронных задач в логический блок, управлять их жизненным циклом и обрабатывать ошибки централизованно.

Плюсы: все задачи в scope объединены, нет «разбросанных Future», автоматическая отмена всех задач при ошибке одной, лёгкое объединение результатов (scope.join()), отлично работает с виртуальными потоками (Loom) для масштабируемости.

Минусы: пока инкубаторная API (Java 19–25), не заменяет синхронизацию данных.

try (var scope = new StructuredTaskScope.ShutdownOnFailure<String>()) {
    var f1 = scope.fork(() -> "Task 1");
    var f2 = scope.fork(() -> "Task 2");

    scope.join();
    scope.throwIfFailed();

    System.out.println(f1.resultNow());
    System.out.println(f2.resultNow());
}

Схема:

             +---------------------------+
             | StructuredTaskScope       |
             |                           |
             |  [Task1]  [Task2] [Task3] |
             |       ...                 |
             +-----------+---------------+
                         |
                     Scope.join()
                         |
                 All results / Errors

Все задачи объединены в один scope.
Ошибка одной задачи → автоматически отменяются остальные.
Легко собирать результаты и обрабатывать исключения централизованно.

4. Реактивные библиотеки

RxJava, Project Reactor и др. предлагают мощные абстракции для потоков событий и асинхронных данных. Поддержка back-pressure, множественных событий, комбинирования потоков. Используются для высоконагруженных систем и микросервисов.

Схема:

[Source Observable] --> [map/filter] --> [flatMap/merge] --> [Subscriber]

Поток событий от источника к подписчику.
Поддержка backpressure.
Множество событий, параллельная обработка, объединение потоков.

5. Общая сравнительная таблица

Сравнение производительности и масштабируемости механизмов асинхронности в Java

Ниже представлена сравнительная таблица основных подходов к асинхронности в Java: Future, CompletableFuture, Structured Concurrency и реактивные библиотеки (RxJava / Reactor). Таблица фокусируется на производительности, масштабируемости, блокировках и особенностях использования потоков.

Итог

• Future<T> — для простых задач с блокирующим ожиданием.
• CompletableFuture — универсальный инструмент для асинхронных цепочек и комбинирования задач.
• Structured Concurrency — современный подход для Production: объединяет задачи в логический блок, управляет ошибками и отменой автоматически.
• Реактивные библиотеки — для потоков событий и высоконагруженных систем.

Для Production на Java 25 оптимальным сочетанием сегодня является Structured Concurrency + Virtual Threads (Loom): безопасное, масштабируемое и структурированное управление задачами.