Что такое Feature?

# Что такое Future?

Краткий ответ

Future - это интерфейс в Java, который представляет результат асинхронной операции. Future позволяет запустить операцию в отдельном потоке и позже получить результат, без необходимости ждать, пока операция завершится.

1. Основы Future

Что это: Интерфейс из пакета java.util.concurrent

Как это работает:

Основной поток                  Рабочий поток
         ↓                             ↓
  task.submit()  --------→   Выполняется операция
         ↓                             ↓
  future.get()   ← ← ← ← ← ← Результат готов
         ↓
  Получить результат

Синтаксис:

ExecutorService executor = Executors.newSingleThreadExecutor();

// Запустить асинхронную задачу
Future<Integer> future = executor.submit(() -> {
    Thread.sleep(2000);  // Долгая операция
    return 42;
});

// Сделать другую работу пока выполняется задача
System.out.println("Задача запущена");

// Получить результат (ждет если не готов)
Integer result = future.get();  // Блокирует до готовности
System.out.println("Результат: " + result);  // 42

executor.shutdown();

2. Методы Future

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

Future<String> future = executor.submit(() -> {
    Thread.sleep(3000);
    return "Hello";
});

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

// С таймаутом
try {
    String result = future.get(5, TimeUnit.SECONDS);  // Ждет максимум 5 секунд
} catch (TimeoutException e) {
    System.out.println("Операция заняла слишком много времени");
}

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

Future<Integer> future = executor.submit(() -> {
    Thread.sleep(2000);
    return 100;
});

while (!future.isDone()) {
    System.out.println("Ожидание...");
    Thread.sleep(500);
}

Integer result = future.get();  // Готов, вернет сразу

cancel() - отменить задачу

Future<Long> future = executor.submit(() -> {
    Thread.sleep(10000);
    return System.currentTimeMillis();
});

// Отменить до выполнения
boolean cancelled = future.cancel(true);  // true = прервать если выполняется

if (cancelled) {
    System.out.println("Задача отменена");
} else {
    System.out.println("Не удалось отменить (уже выполняется или завершена)");
}

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

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

3. Примеры использования

Простой пример

public class FutureExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        
        // Задача 1: вычисление
        Future<Integer> future1 = executor.submit(() -> {
            System.out.println("Задача 1 начата");
            Thread.sleep(2000);
            System.out.println("Задача 1 завершена");
            return 10;
        });
        
        // Задача 2: вычисление
        Future<Integer> future2 = executor.submit(() -> {
            System.out.println("Задача 2 начата");
            Thread.sleep(3000);
            System.out.println("Задача 2 завершена");
            return 20;
        });
        
        // Основной поток может сделать другую работу
        System.out.println("Основной поток работает");
        
        // Получить результаты
        Integer result1 = future1.get();  // Ждет задачу 1
        Integer result2 = future2.get();  // Ждет задачу 2
        
        System.out.println("Сумма: " + (result1 + result2));  // 30
        
        executor.shutdown();
    }
}

// Вывод:
// Основной поток работает
// Задача 1 начата
// Задача 2 начата
// Задача 1 завершена
// Задача 2 завершена
// Сумма: 30

Обработка результатов с TimeOut

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<String> future = executor.submit(() -> {
    // Имитация долгой операции
    Thread.sleep(5000);
    return "Результат";
});

try {
    String result = future.get(3, TimeUnit.SECONDS);  // TimeOut 3 сек
    System.out.println(result);
} catch (TimeoutException e) {
    System.out.println("Операция заняла больше 3 секунд");
    future.cancel(true);  // Отменить
} catch (InterruptedException e) {
    System.out.println("Поток был прерван");
} catch (ExecutionException e) {
    System.out.println("Ошибка при выполнении: " + e.getCause());
} finally {
    executor.shutdown();
}

4. Проблемы с Future

Проблема 1: Блокировка

// get() блокирует текущий поток
Integer result = future.get();  // Здесь поток заморозится

Проблема 2: Сложная комбинация

// Сложно комбинировать несколько Future
Future<Integer> f1 = executor.submit(() -> 10);
Future<Integer> f2 = executor.submit(() -> 20);
Future<Integer> f3 = executor.submit(() -> {
    return f1.get() + f2.get();  // Блокировка внутри задачи
});

Проблема 3: Обработка ошибок

try {
    Integer result = future.get();
} catch (ExecutionException e) {  // Нужно обрабатывать
    System.out.println("Ошибка: " + e.getCause());
}

5. CompletableFuture - улучшенная версия

Future имеет ограничения. Java 8 добавила CompletableFuture, которая решает эти проблемы:

// Future - блокирующий
Future<Integer> future = executor.submit(() -> {
    Thread.sleep(2000);
    return 42;
});
Integer result = future.get();  // Блокирует

// CompletableFuture - неблокирующий
CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {}
    return 42;
});

// Не блокирует! Callback будет вызван когда готов результат
cf.thenAccept(result -> {
    System.out.println("Результат готов: " + result);
});

// Комбинирование
CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> cf2 = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> cf3 = cf1.thenCombine(cf2, (a, b) -> a + b);

6. Сравнение Future и CompletableFuture

7. Типы ExecutorService для Future

// Single Thread
ExecutorService single = Executors.newSingleThreadExecutor();

// Fixed Pool
ExecutorService pool = Executors.newFixedThreadPool(4);

// Cached Pool
ExecutorService cached = Executors.newCachedThreadPool();

// Scheduled
ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(2);

8. Полный пример - параллельная загрузка данных

public class DataFetcher {
    private ExecutorService executor = Executors.newFixedThreadPool(3);
    
    public void fetchDataInParallel() throws Exception {
        // Запустить 3 операции параллельно
        Future<String> usersFuture = executor.submit(() -> fetchUsers());
        Future<String> postsFuture = executor.submit(() -> fetchPosts());
        Future<String> commentsFuture = executor.submit(() -> fetchComments());
        
        // Ждать всех
        String users = usersFuture.get(5, TimeUnit.SECONDS);
        String posts = postsFuture.get(5, TimeUnit.SECONDS);
        String comments = commentsFuture.get(5, TimeUnit.SECONDS);
        
        System.out.println("Users: " + users);
        System.out.println("Posts: " + posts);
        System.out.println("Comments: " + comments);
    }
    
    private String fetchUsers() throws Exception {
        Thread.sleep(2000);
        return "Users data";
    }
    
    private String fetchPosts() throws Exception {
        Thread.sleep(3000);
        return "Posts data";
    }
    
    private String fetchComments() throws Exception {
        Thread.sleep(1000);
        return "Comments data";
    }
}

Заключение

• Future - интерфейс для работы с результатами асинхронных операций
• get() - получить результат (блокирует)
• isDone() - проверить готовность
• cancel() - отменить задачу
• Для сложных асинхронных цепочек используй CompletableFuture
• Future полезен для параллельных вычислений и I/O операций