Для чего нужен Future в Java?

# Future в Java: Асинхронные вычисления

Определение

Future — это интерфейс в Java (из пакета java.util.concurrent), который представляет результат асинхронного вычисления, который станет доступен в будущем. Это способ работать с длительными операциями без блокирования потока.

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

// Без Future - синхронный блокирующий код
String result = heavyOperation();  // Ждём, пока операция завершится
System.out.println("Результат: " + result);

// С Future - асинхронный код
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> future = executor.submit(() -> heavyOperation());

// Можем делать другие дела, пока операция выполняется
System.out.println("Жду результат...");

// Когда нужен результат, получаем его (может заблокировать)
String result = future.get();  // Блокирует, если ещё не готово
System.out.println("Результат: " + result);

Практический пример 1: Download файлов

@Service
public class FileDownloadService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(5);
    
    // Синхронный подход - блокирует
    public List<String> downloadFilesSync(List<String> urls) {
        List<String> results = new ArrayList<>();
        for (String url : urls) {
            String content = restTemplate.getForObject(url, String.class);
            results.add(content);
        }
        return results;  // Это долго если много файлов!
    }
    
    // Асинхронный подход с Future
    public List<String> downloadFilesAsync(List<String> urls) 
            throws ExecutionException, InterruptedException {
        
        // Запускаем загрузку всех файлов параллельно
        List<Future<String>> futures = urls.stream()
                .map(url -> executor.submit(() -> downloadFile(url)))
                .collect(Collectors.toList());
        
        // Собираем результаты
        List<String> results = new ArrayList<>();
        for (Future<String> future : futures) {
            results.add(future.get());  // Блокирует если не готово
        }
        
        return results;  // Это быстрее!
    }
    
    private String downloadFile(String url) {
        return restTemplate.getForObject(url, String.class);
    }
}

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

1. get() - получить результат

Future<Integer> future = executor.submit(() -> calculateSum());

// Блокирует, пока результат не готов
Integer result = future.get();  // Ждёт бесконечно

// С таймаутом
Integer result = future.get(5, TimeUnit.SECONDS);  // Ждёт макс 5 сек

2. isDone() - проверить готовность

Future<String> future = executor.submit(() -> longOperation());

while (!future.isDone()) {
    System.out.println("Ещё выполняется...");
    Thread.sleep(1000);
}

String result = future.get();  // Уже готово, не блокирует

3. cancel() - отменить операцию

Future<String> future = executor.submit(() -> veryLongOperation());

Thread.sleep(2000);

boolean cancelled = future.cancel(true);  // true = interrupt поток
if (cancelled) {
    System.out.println("Операция отменена");
} else {
    System.out.println("Не смогли отменить (уже готово)");
}

4. isCancelled() - проверить отмену

Future<String> future = executor.submit(() -> operation());

future.cancel(true);

if (future.isCancelled()) {
    System.out.println("Была отменена");
}

Пример 2: Параллельные запросы к API

@RestController
@RequestMapping("/api/data")
public class DataController {
    
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(10);
    
    @GetMapping("/combined")
    public ResponseEntity<CombinedData> getCombinedData() 
            throws ExecutionException, InterruptedException {
        
        // Запускаем 3 операции параллельно
        Future<UserData> userFuture = executor.submit(this::fetchUserData);
        Future<OrderData> orderFuture = executor.submit(this::fetchOrderData);
        Future<StatisticsData> statsFuture = executor.submit(this::fetchStatistics);
        
        // Получаем результаты (в порядке готовности)
        UserData userData = userFuture.get();
        OrderData orderData = orderFuture.get();
        StatisticsData statsData = statsFuture.get();
        
        // Объединяем данные
        CombinedData result = new CombinedData(
            userData, orderData, statsData
        );
        
        return ResponseEntity.ok(result);
    }
    
    private UserData fetchUserData() {
        // Долгая операция - например, запрос к БД
        return new UserData(/* ... */);
    }
    
    private OrderData fetchOrderData() {
        // Долгая операция
        return new OrderData(/* ... */);
    }
    
    private StatisticsData fetchStatistics() {
        // Долгая операция
        return new StatisticsData(/* ... */);
    }
}

Пример 3: Обработка результата с обработкой ошибок

@Service
public class EmailService {
    
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(5);
    
    public void sendEmailAsync(String email, String message) {
        Future<Boolean> future = executor.submit(
            () -> sendEmail(email, message)
        );
        
        // Запускаем проверку в отдельном потоке
        executor.submit(() -> {
            try {
                Boolean success = future.get(10, TimeUnit.SECONDS);
                if (success) {
                    log.info("Email sent successfully to: {}", email);
                } else {
                    log.warn("Failed to send email to: {}", email);
                }
            } catch (TimeoutException e) {
                log.error("Email sending timed out for: {}", email);
                future.cancel(true);
            } catch (Exception e) {
                log.error("Error sending email: {}", e.getMessage());
            }
        });
    }
    
    private Boolean sendEmail(String email, String message) {
        // Логика отправки
        return true;
    }
}

Пример 4: invokeAll() - ждать все futures

@Service
public class BatchProcessingService {
    
    private final ExecutorService executor = 
        Executors.newFixedThreadPool(10);
    
    public List<ProcessingResult> processBatch(List<Item> items) 
            throws InterruptedException {
        
        // Создаём задачи для каждого элемента
        List<Callable<ProcessingResult>> tasks = items.stream()
                .map(item -> (Callable<ProcessingResult>) 
                    () -> processItem(item))
                .collect(Collectors.toList());
        
        // Запускаем все задачи и ждём завершения
        List<Future<ProcessingResult>> futures = 
            executor.invokeAll(tasks);  // Блокирует
        
        // Собираем результаты
        List<ProcessingResult> results = new ArrayList<>();
        for (Future<ProcessingResult> future : futures) {
            results.add(future.get());
        }
        
        return results;
    }
    
    private ProcessingResult processItem(Item item) {
        // Долгая обработка
        return new ProcessingResult(item.getId(), "processed");
    }
}

Future vs CompletableFuture

Future (старый подход - Java 5+)

Future<String> future = executor.submit(() -> operation());
String result = future.get();  // Блокирует

CompletableFuture (новый подход - Java 8+)

CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> operation(), executor)
    .thenApply(String::toUpperCase)
    .thenAccept(System.out::println);

// Не блокирует, использует callbacks

Сравнение подходов

Синхронный код

public List<String> fetchData() {
    String user = getUser();        // 1s
    String orders = getOrders();    // 1s
    String profile = getProfile();  // 1s
    return Arrays.asList(user, orders, profile);  // Итого: 3s
}

С Future (параллельный)

public List<String> fetchData() throws Exception {
    Future<String> userFuture = executor.submit(this::getUser);       // 1s
    Future<String> ordersFuture = executor.submit(this::getOrders);   // 1s
    Future<String> profileFuture = executor.submit(this::getProfile); // 1s
    
    // Все выполняются параллельно
    return Arrays.asList(
        userFuture.get(),
        ordersFuture.get(),
        profileFuture.get()
    );  // Итого: 1s вместо 3s!
}

Опасности и best practices

1. Deadlock опасность

// ОПАСНО - может привести к deadlock
Future<String> future1 = executor.submit(() -> {
    Future<String> future2 = executor.submit(() -> "inner");
    return future2.get();  // Ждём inner, но потоков может не быть!
});

String result = future1.get();  // Ждём outer

2. Всегда используйте таймауты

// ХОРОШО - с таймаутом
try {
    String result = future.get(5, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    future.cancel(true);
    log.error("Operation timed out");
}

// ПЛОХО - может зависнуть навсегда
String result = future.get();

3. Правильное завершение ExecutorService

try {
    executor.shutdown();  // Принимает новые задачи
    if (!executor.awaitTermination(10, TimeUnit.SECONDS)) {
        executor.shutdownNow();  // Отменяет текущие задачи
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
    Thread.currentThread().interrupt();
}

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

✅ Используй Future когда:

• Нужно выполнить долгие операции параллельно
• Хочешь получить результат позже
• Нужна простая асинхронность
• Используешь Java < 8

❌ Используй CompletableFuture когда:

• Нужна цепочка асинхронных операций
• Нужны callbacks
• Используешь Java 8+
• Нужна комбинация нескольких futures

Резюме

Future — это интерфейс для работы с асинхронными вычислениями:

• Позволяет выполнять долгие операции в отдельных потоках
• Не блокирует основной поток выполнения
• Позволяет получить результат позже через get()
• Обеспечивает существенное улучшение производительности при параллельных операциях

Однако, CompletableFuture (Java 8+) — более современное и удобное решение для большинства случаев.