Future.get(): примеры (JAVA)

Короткие примеры использования Future.get()

Пример 1. Успешное выполнение и получение результата:

import java.util.concurrent.*;

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> "ok");
try {
    String r = f.get();
    System.out.println(r);
} catch (Exception e) {
    e.printStackTrace();
}
es.shutdown();

ok

Пример 2. get() с таймаутом - TimeoutException при долгой задаче:

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> { Thread.sleep(2000); return "done"; });
try {
    String r = f.get(500, TimeUnit.MILLISECONDS);
    System.out.println(r);
} catch (TimeoutException te) {
    System.out.println("timeout");
} finally {
    es.shutdown();
}

timeout

Пример 3. Исключение в задаче - ExecutionException обёртывает исходное:

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> { throw new IllegalStateException("boom"); });
try {
    f.get();
} catch (ExecutionException ee) {
    System.out.println(ee.getCause().getClass().getSimpleName() + ": " + ee.getCause().getMessage());
} finally {
    es.shutdown();
}

IllegalStateException: boom

Пример 4. Отмена задачи и CancellationException:

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> { Thread.sleep(2000); return "x"; });
f.cancel(true);
try {
    f.get();
} catch (CancellationException ce) {
    System.out.println("cancelled");
} finally {
    es.shutdown();
}

cancelled

Похожие возможности в Java

Короткий обзор схожих API и их отличий:

• CompletableFuture.get(): обеспечивает те же сигнатуры, но дополнительно поддерживает функциональные комбинирования через thenApply, whenComplete и т.д. Подходит при необходимости цепочек и неблокирующей обработки.
• CompletableFuture.join(): возвращает результат или бросает CompletionException без объявленного InterruptedException. Удобен в стримах, но требует аккуратности при анализе причины исключения.
• FutureTask: конкретная реализация Future, даёт возможность вручную запускать задачу и вызывать get().
• ExecutorService.invokeAll/invokeAny: массовые операции для коллекций задач. invokeAll возвращает список Futures и ждёт завершения всех; может быть удобнее, чем вызов get() для каждой задачи вручную.
• ExecutorCompletionService: упрощает обработку результатов по мере готовности, избегая необходимости блокироваться на конкретном Future.

Аналоги в других языках и отличия

Короткие примеры и ключевые отличия по языкам:

• JavaScript: Promise и оператор await. Поведение неблокирующее в одном потоке, управление контекстом выполнения отличается от многопоточности Java.

  // async/await
  async function f() {
    return 'ok';
  }
  (async () => console.log(await f()))();

  ok

• Python: concurrent.futures.Future.result(timeout=None). API и исключения похожи: TimeoutError, CancelledError, исходные исключения проксируются.

  from concurrent.futures import ThreadPoolExecutor
  
  with ThreadPoolExecutor() as ex:
      f = ex.submit(lambda: 'ok')
      print(f.result())

  ok

• C#: Task<T>.Result (блокирует) и оператор await. Исключения оборачиваются в AggregateException при синхронном доступе.

  // async/await
  using System;
  using System.Threading.Tasks;
  
  Console.WriteLine(Task.FromResult("ok").Result);

  ok

• Go: модели с каналами и goroutine. Нет прямого аналога, ожидание результата через канал или sync.WaitGroup.

  ch := make(chan string)
  go func() { ch <- "ok" }()
  fmt.Println(<-ch)

  ok

• Kotlin: Deferred.await() в корутинах. Отличие в диспетчеризации и поддержке структурированных конкурентов.

  import kotlinx.coroutines.*
  
  runBlocking {
    val d = async { "ok" }
    println(d.await())
  }

  ok

• PHP: нативных Future нет; используются библиотеки (ReactPHP, Guzzle promises). Подход асинхронный, основан на событийном цикле.
• Lua: корутины и сторонние библиотеки для асинхронности. Доступы к результату обычно неблокирующие и управляются планировщиком.
• SQL: синхронный характер запросов на стороне сервера, асинхронность реализуется в клиентских библиотеках; прямого аналога Future.get() нет.

Ключевые отличия: большинство современных языков переходят от блокирующего ожидания к неблокирующим моделям (Promise/async-await, корутины). Java остаётся многопоточной и предоставляет как блокирующие (Future.get()), так и неблокирующие (CompletableFuture, реактивные библиотеки) варианты.

Типичные ошибки при работе с Future.get()

• Блокировка UI или критического потока: вызов get() в GUI-потоке или в потоке обработки запросов может приводить к зависанию.
• Игнорирование InterruptedException: перехват и подавление прерывания мешает корректной отмене задач и потоку.
• Неправильная обработка ExecutionException: не извлечение getCause() приводит к потере информации об исходной ошибке.
• Неверное использование таймаута и TimeUnit: путаница единиц времени ведёт к неожиданным TimeoutException.
• Deadlock при однопоточном пуле: задача ожидает результат другой задачи, которая не может запуститься, пока вызывающий поток занят ожиданием.
• Не вызван shutdown у ExecutorService: утечки потоков при завершении приложения.

Пример ошибки: deadlock из-за однопоточного пула:

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f1 = es.submit(() -> {
    // внутри этой задачи попытка синхронно получить результат другой задачи, но пул однопоточный
    Future<String> f2 = es.submit(() -> "inner");
    return f2.get(); // блокировка навсегда
});
try { System.out.println(f1.get()); } catch (Exception e) { e.printStackTrace(); }
es.shutdown();

[приложение зависнет, никакого результата]

Пример плохой обработки InterruptedException:

try {
    future.get();
} catch (InterruptedException e) {
    // пустой перехват: прерывание теряется
} catch (ExecutionException e) {
    e.printStackTrace();
}

[прерывание игнорируется, корректная отмена не происходит]

Изменения и история

Интерфейс Future и метод get() введены в Java 5 (JDK 1.5). С тех пор сигнатуры get() и get(long, TimeUnit) не изменялись. В Java 8 появился класс CompletableFuture, расширяющий возможности асинхронной обработки и дополнивший модель Future удобными неблокирующими операциями.

В более поздних версиях (инкубаторы структурированной конкуренции в JDK 19-21) добавляются новые подходы к управлению жизненным циклом параллельных задач, однако метод Future.get() как таковой остаётся частью обратной совместимости и не претерпел изменений API.

Расширенные и редкие сценарии применения

Пример 1. Использование ExecutorCompletionService для обработки результатов по мере готовности:

ExecutorService es = Executors.newFixedThreadPool(3);
CompletionService<Integer> cs = new ExecutorCompletionService<>(es);
for (int i = 0; i < 5; i++) {
    final int id = i;
    cs.submit(() -> { Thread.sleep(500L * id); return id; });
}
for (int i = 0; i < 5; i++) {
    Future<Integer> f = cs.take(); // ждёт ближайший завершённый
    System.out.println("Got: " + f.get());
}
es.shutdown();

Got: 0
Got: 1
Got: 2
Got: 3
Got: 4

Пример 2. Преобразование Future в CompletableFuture для неблокирующей обработки:

// адаптер: обёртка Future в CompletableFuture
public static <T> CompletableFuture<T> toCompletableFuture(Future<T> future, Executor executor) {
    return CompletableFuture.supplyAsync(() -> {
        try { return future.get(); }
        catch (Exception e) { throw new CompletionException(e.getCause() != null ? e.getCause() : e); }
    }, executor);
}

// использование
ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> "ok");
CompletableFuture<String> cf = toCompletableFuture(f, ForkJoinPool.commonPool());
cf.thenAccept(System.out::println);
es.shutdown();

ok

Пример 3. Протокол отмены: отмена внешнего Future и попытка прервать задачу-источник:

ExecutorService es = Executors.newSingleThreadExecutor();
Future<String> f = es.submit(() -> {
    try {
        while (!Thread.currentThread().isInterrupted()) {
            // работа
        }
    } catch (Exception ignored) {}
    return "stopped";
});
// внешняя отмена
f.cancel(true);
try {
    f.get();
} catch (CancellationException ce) {
    System.out.println("cancelled");
}
es.shutdown();

cancelled

Пример 4. Комбинация invokeAll и анализ результата с таймаутом:

ExecutorService es = Executors.newFixedThreadPool(3);
List<Callable<String>> tasks = List.of(
    () -> { Thread.sleep(100); return "A"; },
    () -> { Thread.sleep(300); return "B"; },
    () -> { Thread.sleep(500); return "C"; }
);
try {
    List<Future<String>> res = es.invokeAll(tasks, 400, TimeUnit.MILLISECONDS);
    for (Future<String> f : res) {
        if (f.isCancelled()) System.out.println("cancelled");
        else System.out.println(f.get());
    }
} finally { es.shutdown(); }

A
B
cancelled

Пример 5. Использование FutureTask для отложенного выполнения и внешнего контроля состояния:

FutureTask<Integer> ft = new FutureTask<>(() -> { Thread.sleep(200); return 42; });
Thread t = new Thread(ft);
t.start();
System.out.println(ft.get());

42

Пояснения: примеры показывают способы обработки результатов по мере готовности, преобразование блокирующего API в неблокирующий, корректную отмену задач и защиту от блокировок пула потоков. В реальных системах предпочтение отдаётся неблокирующей обработке (CompletableFuture, реактивные подходы) там, где это возможно, а Future.get() остаётся удобным и понятным инструментом для синхронного ожидания результата.