Как на собеседовании параллельно получить данные из 4 независимых систем через CompletableFuture?

Как параллельно получить данные из 4 независимых систем через CompletableFuture?

• Java concurrency и асинхронное выполнение
• CompletableFuture — оболочка для асинхронных вычислений
• Запускать каждый запрос в пуле потоков через CompletableFuture.supplyAsync()
• Создать 4 CompletableFuture, соответствующих отдельным запросам
• Объединить их методом CompletableFuture.allOf(), чтобы дождаться завершения всех задач
• После allOf() извлечь результаты из каждого future с помощью .join() или .get()
• Параллельное выполнение сокращает суммарное время ожидания и повышает throughput
• Использовать ForkJoinPool.commonPool либо собственный Executor для управления пулом потоков
• Обрабатывать исключения через .exceptionally() или handle(), чтобы ошибки не терялись
• Практический сценарий: ускорение обращений к микросервисам или сторонним API

Схематичный пример кода:

CompletableFuture<Data1> cf1 = CompletableFuture.supplyAsync(() -> fetchFromSystem1());
CompletableFuture<Data2> cf2 = CompletableFuture.supplyAsync(() -> fetchFromSystem2());
CompletableFuture<Data3> cf3 = CompletableFuture.supplyAsync(() -> fetchFromSystem3());
CompletableFuture<Data4> cf4 = CompletableFuture.supplyAsync(() -> fetchFromSystem4());

CompletableFuture<Void> all = CompletableFuture.allOf(cf1, cf2, cf3, cf4);

all.thenRun(() -> {
Data1 d1 = cf1.join();
Data2 d2 = cf2.join();
Data3 d3 = cf3.join();
Data4 d4 = cf4.join();
// обработка результатов
}).exceptionally(ex -> {
// обработка ошибок
return null;
});

Кратко: параллельно запускаем запросы через supplyAsync(), ждём их завершения с allOf(), а затем получаем результаты методом join().

Развёрнутый ответ

Основная идея

Чтобы параллельно запросить данные из 4 независимых систем в Java, удобно применить CompletableFuture из пакета java.util.concurrent. Такой подход запускает асинхронные операции без блокировки основного потока и упрощает объединение результатов после завершения всех вызовов.

Общая последовательность действий выглядит так: для каждой системы создаётся отдельный CompletableFuture, внутри которого асинхронно выполняется запрос, например с помощью supplyAsync. Затем все четыре future объединяются методом allOf. Полученный объект завершится только после выполнения каждого запроса, после чего из future можно извлечь данные и продолжить их обработку.

Что важно учесть

• Асинхронность: вызов CompletableFuture.supplyAsync(() -> fetchData()) выполняет задачу в ForkJoinPool.commonPool() либо в переданном собственном Executor’е, поэтому основной поток не блокируется.
• Объединение результатов: вызов CompletableFuture.allOf(future1, future2, future3, future4) возвращает CompletableFuture<Void>, который будет завершён после выполнения всех четырёх задач. Затем конкретные значения можно получить через futureX.join().
• Обработка ошибок: методы handle, exceptionally и whenComplete позволяют обработать ошибки отдельных запросов и не остановить из-за них весь процесс.

Пример из практики

В реальных проектах этот подход можно применять при обращении к нескольким REST-сервисам через WebClient или HttpClient, когда сервер агрегирует полученные данные. Четыре запроса запускаются почти одновременно: при latency около ~100ms для каждого общее ожидание составляет примерно 100ms, а не ~400ms при последовательном выполнении. В React 18 похожий принцип используется с Suspense для параллельного рендеринга данных.

Такой шаблон хорошо масштабируется и поддерживает отзывчивость приложения. Особенно полезен он в микросервисной архитектуре, где независимые внешние вызовы требуется выполнять параллельно, снижая общую задержку.