Какие плюсы и минусы CompletableFuture?

# Плюсы и минусы CompletableFuture в Java

CompletableFuture — это класс из пакета java.util.concurrent, введённый в Java 8, который позволяет писать асинхронный и неблокирующий код. Это мощный инструмент для работы с асинхронными операциями, который пришёл на смену Future и callback-based подходам.

Плюсы CompletableFuture

1. Удобный API для асинхронного кода

CompletableFuture предоставляет functional API с использованием lambda-функций:

// Вместо обычного Future
Future<String> future = executor.submit(() -> "Result");
String result = future.get();  // Блокирующий вызов!

// CompletableFuture
CompletableFuture<String> cf = CompletableFuture
    .supplyAsync(() -> "Result")
    .thenApply(s -> s + "!")  // Неблокирующая цепочка
    .thenAccept(System.out::println);

2. Цепочки операций (chaining)

Можно легко создавать цепочки асинхронных операций без колбэков:

CompletableFuture<User> user = fetchUser(userId)
    .thenCompose(u -> fetchUserPreferences(u))  // flatMap
    .thenApply(u -> enrichUser(u))              // map
    .thenAccept(u -> saveToCache(u));           // side effect

3. Комбинирование нескольких future

Комбинирование результатов нескольких асинхронных операций:

CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> "World");

// Ждём обе
CompletableFuture<String> combined = cf1.thenCombine(cf2, (a, b) -> a + " " + b);

// Ждём первую
CompletableFuture<Object> first = CompletableFuture.anyOf(cf1, cf2);

// Ждём все три
CompletableFuture<Void> allOf = CompletableFuture.allOf(cf1, cf2);

4. Обработка исключений

Удобная обработка ошибок в асинхронной цепочке:

CompletableFuture<String> cf = fetchData()
    .exceptionally(ex -> {
        logger.error("Error: ", ex);
        return "Default value";
    })
    .handle((result, ex) -> {
        if (ex != null) {
            return "Error: " + ex.getMessage();
        }
        return result;
    });

5. Ручное заполнение значения

Можно создать CompletableFuture, а потом заполнить его значение извне:

CompletableFuture<String> cf = new CompletableFuture<>();

// В другом потоке
if (condition) {
    cf.complete("Success");
} else {
    cf.completeExceptionally(new Exception("Failed"));
}

// Основной поток может дождаться
String result = cf.get();

6. Таймауты

Можно установить таймаут для операции:

CompletableFuture<String> cf = fetchData();

try {
    String result = cf.orTimeout(5, TimeUnit.SECONDS)
        .get();
} catch (ExecutionException e) {
    // Обработка ошибки
}

7. Не требует явного потокового пула

По умолчанию использует ForkJoinPool.commonPool():

CompletableFuture.supplyAsync(() -> "Default pool");

// Или свой executor
Executor executor = Executors.newFixedThreadPool(5);
CompletableFuture.supplyAsync(() -> "Custom pool", executor);

8. Лучше, чем callback-hell

// Callback-hell (ужасно читается)
fetchUser(id, user -> {
    fetchPreferences(user.getId(), prefs -> {
        enrichUser(user, prefs, enriched -> {
            saveToCache(enriched, () -> {
                System.out.println("Done");
            });
        });
    });
});

// CompletableFuture (чисто и красиво)
fetchUser(id)
    .thenCompose(u -> fetchPreferences(u.getId()))
    .thenApply(p -> enrichUser(user, p))
    .thenApply(e -> saveToCache(e))
    .thenAccept(v -> System.out.println("Done"));

Минусы CompletableFuture

1. Сложность в освоении

CompletableFuture имеет более 50 методов, что затрудняет обучение:

// Много похожих методов, легко запутаться
thenApply()        // map
thenApplyAsync()   // map в отдельном потоке
thenCompose()      // flatMap
thenCombine()      // zip
whenComplete()     // finally
handle()           // try-finally
exceptionally()    // catch

2. Утечки потоков

Если неправильно управлять executor'ом, можно создать утечку потоков:

// Неправильно: executor никогда не shutdown'ится
Executor executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 1000; i++) {
    CompletableFuture.supplyAsync(() -> work(), executor);
}
// executor.shutdown();  // Забыли!

3. Дебаг сложнее

Stack trace при исключении не показывает полный путь выполнения:

// При ошибке stack trace может быть непонятным
CompletableFuture.supplyAsync(() -> 1 / 0)  // ArithmeticException
    .thenApply(x -> x * 2)
    .join();  // Где именно произошла ошибка?

4. Нет отмены в стиле Future

Отмена (cancellation) работает иначе и может быть неинтуитивной:

CompletableFuture<String> cf = fetchData();
bln cancel = cf.cancel(true);  // Редко работает как ожидается

5. Проблема с общим потоком (ForkJoinPool)

По умолчанию использует common pool, что может привести к задержкам:

// Если в common pool уже занято много потоков,
// ваше supplyAsync может долго ждать очереди
CompletableFuture.supplyAsync(() -> longRunningTask());

6. NullPointerException при null результате

Если операция вернёт null, это может привести к проблемам:

CompletableFuture.supplyAsync(() -> null)
    .thenApply(String::length)  // NPE!
    .join();

7. Сложность с обработкой ошибок в цепочке

Ошибка на одном этапе прерывает всю цепочку:

CompletableFuture.supplyAsync(() -> 1 / 0)      // Ошибка!
    .thenApply(x -> x * 2)                      // Не выполняется
    .thenAccept(x -> System.out.println(x));    // Не выполняется

8. Memory overhead

Каждый CompletableFuture требует создания объекта, что использует память:

// Если создать 1 млн CompletableFuture, будет 1 млн объектов
for (int i = 0; i < 1_000_000; i++) {
    CompletableFuture.supplyAsync(() -> someWork());
}

Практический пример с лучшими практиками

@Service
public class UserService {
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(10);
    
    // Загрузка пользователя с кэшем и таймаутом
    public CompletableFuture<User> getUser(String userId) {
        return CompletableFuture.supplyAsync(() -> {
            User cachedUser = cache.get(userId);
            if (cachedUser != null) return cachedUser;
            return database.find(userId);
        }, executor)
        .orTimeout(5, TimeUnit.SECONDS)
        .exceptionally(ex -> {
            logger.error("Error loading user", ex);
            return new User(userId, "Unknown");  // Fallback
        });
    }
    
    // Комбинирование нескольких операций
    public CompletableFuture<UserProfile> getUserProfile(String userId) {
        return getUser(userId)
            .thenCompose(user -> 
                getPreferences(user).thenApply(prefs -> {
                    user.setPreferences(prefs);
                    return user;
                })
            )
            .thenCombine(
                getRelatedUsers(userId),
                (user, related) -> new UserProfile(user, related)
            );
    }
    
    @PreDestroy
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException ex) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

Когда использовать CompletableFuture

✅ Используй для:

• REST клиентов
• Параллельного выполнения нескольких операций
• Асинхронного обработки данных
• Реактивных приложений

❌ Избегай для:

• Простых синхронных операций
• CPU-bound задач (используй Stream API)
• Если нужна полная реактивная система (используй Reactor/RxJava)

Выводы

CompletableFuture — отличный инструмент для асинхронного программирования в Java, который существенно упрощает код по сравнению с callback-based подходами. Однако требует понимания концепций асинхронности и правильного управления ресурсами. Для более сложных сценариев стоит рассмотреть Reactor или RxJava.