Как получить строковое значение из Future?

Как получить строковое значение из Future?

Future — это одна из основных абстракций для работы с асинхронными операциями в Java. Давайте разберём, как извлечь значение из Future, какие у нас есть варианты и в чём их отличия.

Что такое Future?

Future представляет результат асинхронной операции, которая может быть ещё не готова:

// Future может быть:
// 1. Ещё выполняется
// 2. Завершена успешно (с результатом)
// 3. Завершена с ошибкой (Exception)

Future<String> future = executorService.submit(() -> {
    Thread.sleep(2000);
    return "Hello from async task";
});

// На этом моменте результат ещё не готов!

Способ 1: get() — Блокирующий вызов

ExecutorService executor = Executors.newFixedThreadPool(2);

Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Result ready!";
});

// Способ 1: Простой get()
try {
    String result = future.get();  // Блокирует текущий поток до результата
    System.out.println("Result: " + result);
} catch (InterruptedException e) {
    System.out.println("Task was interrupted");
    Thread.currentThread().interrupt();  // Восстанови flag
} catch (ExecutionException e) {
    System.out.println("Task failed: " + e.getCause());
}

// Способ 2: get() с timeout
try {
    String result = future.get(2, TimeUnit.SECONDS);  // Ждём максимум 2 секунды
    System.out.println("Result: " + result);
} catch (TimeoutException e) {
    System.out.println("Task took too long!");
    future.cancel(true);  // Отмени задачу
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
} catch (ExecutionException e) {
    System.out.println("Task failed: " + e.getCause());
}

Плюсы:

• Просто и понятно
• Синхронный код

Минусы:

• ❌ Блокирует текущий поток
• ❌ Если timeout, нужно вручную обрабатывать
• ❌ Если много Future, получается "callback hell"

Способ 2: isDone() + polling — Опрос состояния

Future<String> future = executor.submit(() -> {
    Thread.sleep(2000);
    return "Async result";
});

// Опрашиваем состояние
while (!future.isDone()) {
    System.out.println("Still waiting...");
    Thread.sleep(500);  // Ждём 500ms и проверяем опять
}

try {
    String result = future.get();  // Теперь уже готово, не будет блокироваться
    System.out.println("Result: " + result);
} catch (ExecutionException e) {
    e.getCause().printStackTrace();
}

Плюсы:

• Можно делать что-то между проверками

Минусы:

• ❌ Расточительно (polling часто проверяет)
• ❌ Нужно самому управлять интервалом

Способ 3: CompletableFuture — Современный подход (Java 8+)

// Вместо Future используем CompletableFuture
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Hello from CompletableFuture";
});

// Способ 1: thenAccept (обработать результат)
future.thenAccept(result -> {
    System.out.println("Result: " + result);
});

// Способ 2: thenApply (преобразовать результат)
CompletableFuture<String> transformed = future.thenApply(result -> {
    return result.toUpperCase();
});

// Способ 3: Объединить несколько асинхронных операций
CompletableFuture<String> step1 = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(500);
    return "Hello";
});

CompletableFuture<String> step2 = step1.thenCompose(result -> {
    // Используем результат из step1 для step2
    return CompletableFuture.supplyAsync(() -> result + " World");
});

// Способ 4: Параллельные операции
CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> "Task1");
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> "Task2");

CompletableFuture<Void> combined = CompletableFuture.allOf(task1, task2);
combined.thenRun(() -> {
    System.out.println("Both tasks completed");
});

// Способ 5: Обработка ошибок
CompletableFuture<String> withError = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Oops!");
}).exceptionally(ex -> {
    System.out.println("Error: " + ex.getMessage());
    return "Fallback value";
});

// Способ 6: Финальная обработка (всегда выполняется)
CompletableFuture<String> withFinally = CompletableFuture.supplyAsync(() -> "Data")
    .whenComplete((result, error) -> {
        if (error != null) {
            System.out.println("Task failed: " + error.getMessage());
        } else {
            System.out.println("Task completed with: " + result);
        }
    });

Плюсы:

• ✅ Асинхронный, не блокирует
• ✅ Цепочки операций (fluent API)
• ✅ Обработка ошибок встроена
• ✅ Комбинирование нескольких futures

Минусы:

• Немного сложнее для новичков

Способ 4: Callback (слушатель результата)

// Часто используется в фреймворках (Spring, Play)
Future<String> future = executor.submit(() -> {
    Thread.sleep(1000);
    return "Async result";
});

// Добавляем слушатель (если Future это поддерживает)
if (future instanceof ListenableFuture) {
    ListenableFuture<String> listenableFuture = (ListenableFuture<String>) future;
    listenableFuture.addListener(() -> {
        try {
            String result = future.get();
            System.out.println("Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }, executor);
}

Способ 5: Reactive (RxJava, Project Reactor)

// RxJava
Observable<String> observable = Observable.create(emitter -> {
    emitter.onNext("Hello from Observable");
    emitter.onComplete();
});

observable.subscribe(
    result -> System.out.println("Result: " + result),
    error -> System.out.println("Error: " + error),
    () -> System.out.println("Completed")
);

// Project Reactor (Spring WebFlux)
Mono<String> mono = Mono.fromSupplier(() -> {
    return "Hello from Mono";
});

mono.subscribe(
    result -> System.out.println("Result: " + result),
    error -> System.out.println("Error: " + error),
    () -> System.out.println("Completed")
);

Практический пример: API вызовы

// REST Client для асинхронных запросов
@Service
public class UserApiClient {
    private final RestTemplate restTemplate;
    private final ExecutorService executor;
    
    public UserApiClient() {
        this.executor = Executors.newFixedThreadPool(5);
    }
    
    // Способ 1: CompletableFuture (рекомендуется)
    public CompletableFuture<String> fetchUserAsync(long userId) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                // Блокирующий вызов в отдельном потоке
                String result = restTemplate.getForObject(
                    "https://api.example.com/users/" + userId,
                    String.class
                );
                return result;
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        }, executor);
    }
    
    // Использование
    public void processUsers() {
        CompletableFuture<String> user1 = fetchUserAsync(1);
        CompletableFuture<String> user2 = fetchUserAsync(2);
        CompletableFuture<String> user3 = fetchUserAsync(3);
        
        // Ждём все три
        CompletableFuture.allOf(user1, user2, user3)
            .thenRun(() -> {
                System.out.println("All users loaded");
                // user1.join(), user2.join(), user3.join() содержат результаты
            })
            .join();  // Ждём завершения
    }
}

// Способ 2: Spring (очень просто)
@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public CompletableFuture<ResponseEntity<User>> getUser(@PathVariable Long id) {
        // Весь Spring boot знает как работать с CompletableFuture
        return userService.fetchUserAsync(id)
            .thenApply(user -> ResponseEntity.ok(user))
            .exceptionally(ex -> ResponseEntity.status(500).build());
    }
}

Сравнение методов

Лучшие практики

// ❌ Избегай
Future<String> future = executor.submit(task);
String result = future.get();  // Блокирует поток!
// Много futures → потоки блокируются → deadlock

// ✅ Используй CompletableFuture
CompletableFuture<String> future = CompletableFuture.supplyAsync(task);
future.thenAccept(result -> {
    System.out.println(result);
});  // Не блокирует

// ✅ Для Spring WebFlux используй Mono/Flux
Mono<String> mono = Mono.fromFuture(() -> future);
mono.subscribe(System.out::println);

// ✅ Всегда обрабатывай ошибки
CompletableFuture.supplyAsync(() -> { /* code */ })
    .exceptionally(ex -> {
        logger.error("Error: ", ex);
        return "default value";
    });

Итог: CompletableFuture — это стандарт для работы с Future в современной Java. Он асинхронный, гибкий и интегрирован везде (Spring, фреймворки, Java libraries).