Java Callable и Future | W3Docs Learn Java

Runnable позволяет потоку выполнять работу. Но он не позволяет вернуть значение или выбросить проверяемое исключение. Для этого предназначена пара: Callable<V> (производитель) и Future<V> (потребитель). Вы передаёте Callable<V> в ExecutorService и получаете обратно Future<V> — дескриптор, с помощью которого можно: ждать результата, считать значение, перехватить исключение задачи или отменить её.

Это самый низкоуровневый API для работы с результатами в конкурентном инструментарии Java. В следующей главе, CompletableFuture, добавляются цепочки, комбинаторы и конвейеры; но контракт — «асинхронный результат, которого можно ждать» — впервые определил именно Future, и он по-прежнему остаётся правильным инструментом для простого «выполни это и сообщи, когда закончишь».

`Callable<V>` — Runnable с возвращаемым типом

Интерфейс:

@FunctionalInterface
public interface Callable<V> {
  V call() throws Exception;
}

Два отличия от Runnable:

Возвращает V (параметр типа).
Может выбрасывать любое Exception — в том числе проверяемые исключения.

Как и Runnable, это функциональный интерфейс — работают лямбды и ссылки на методы:

Callable<Integer> compute = () -> {
  Thread.sleep(100);
  return 42;
};

Callable<String> read = () -> Files.readString(Path.of("config.txt"));   // can throw IOException

Callable<List<Order>> query = () -> repo.findAll();                       // can throw SQLException

Callable подходит для любой задачи вида «выполни это и верни значение». Runnable уместен только тогда, когда результат вам действительно не нужен.

`Future<V>` — дескриптор асинхронного результата

Когда вы вызываете submit с Callable<V>, исполнитель возвращает Future<V>:

public interface Future<V> {
  boolean cancel(boolean mayInterruptIfRunning);
  boolean isCancelled();
  boolean isDone();
  V get() throws InterruptedException, ExecutionException;
  V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

Пять методов. Три из них используются чаще всего.

`get()`

Блокирует вызывающий поток до завершения задачи, затем возвращает результат:

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> f = pool.submit(() -> { Thread.sleep(100); return 42; });
Integer value = f.get();                              // blocks until done; returns 42

get() может выбросить три исключения, которые необходимо обработать:

InterruptedException — вызывающий поток был прерван во время ожидания. Стандартная обработка: восстановить флаг прерывания и передать исключение дальше.
ExecutionException — задача сама выбросила исключение. Оригинальное исключение обёрнуто; получить его можно через .getCause().
CancellationException — кто-то вызвал cancel() на этом future.

Типичный шаблон:

try {
  Integer v = f.get();
} catch (ExecutionException e) {
  Throwable cause = e.getCause();                     // the real exception the task threw
  // ... handle cause ...
} catch (InterruptedException e) {
  Thread.currentThread().interrupt();
  // ... bail out cooperatively ...
}

`get(timeout, unit)`

То же, что get(), но с дедлайном. Выбрасывает TimeoutException, если задача не завершилась вовремя:

try {
  Integer v = f.get(500, TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
  f.cancel(true);                                     // give up; ask the task to stop
  throw new ServiceUnavailableException("timed out");
}

Это правильный шаблон для «я обращаюсь к бэкенду, который должен ответить за N мс; иначе — быстрый сбой». Всегда сопровождайте перехват cancel(true) — иначе задача продолжит выполняться в фоне, занимая поток, результат которого вам уже не нужен.

`cancel(boolean)`

Просит задачу остановиться:

boolean cancelled = f.cancel(true);                   // true = interrupt the running thread

Аргумент указывает исполнителю, нужно ли прерывать рабочий поток. При true рабочий поток получит InterruptedException от любого блокирующего вызова (sleep, wait, I/O); при false отмена не имеет эффекта, если задача уже запущена — из очереди удаляются только ещё не стартовавшие задачи.

cancel работает кооперативно. Задача, которая не проверяет Thread.currentThread().isInterrupted() и не делает блокирующих вызовов, продолжит выполняться до конца. Отмена — не аварийное завершение, а запрос, который задача должна соблюдать.

Исключения: правило обёртки

Всё, что выбросит Callable, при вызове get оборачивается в ExecutionException. Причина — исходный throwable:

Future<Integer> f = pool.submit(() -> { throw new IOException("nope"); });
try {
  f.get();
} catch (ExecutionException e) {
  e.getCause();                                       // IOException("nope")
  e.getCause() instanceof IOException;                // true
}

Обратите внимание на асимметрию: Callable может выбросить проверяемое исключение (объявленное throws Exception в сигнатуре), но Future.get объявляет только ExecutionException. Обёртка позволяет одной сигнатуре нести любой возможный сбой.

Перегрузка Runnable.submit — pool.submit(Runnable) — возвращает Future<?>, чей get() при успехе возвращает null и по-прежнему оборачивает любое непойманное RuntimeException из Runnable. Это стандартный способ обнаружить, что «запустили и забыли» Runnable на самом деле завершился с ошибкой.

Ограничения `Future`

Future — однонаправленный канал: вы отправляете задачу, ждёте и получаете значение. Он не поддерживает композицию:

Нельзя сказать «когда это завершится — запусти то с результатом».
Нельзя сказать «когда завершится любой из этих N — сделай X».
Нельзя сказать «объедини результаты этих двух futures без блокировки».

Для всего этого нужен CompletableFuture (следующая глава). Future — правильный инструмент, когда:

Нужно просто получить значение от одной задачи.
Вы используете API, возвращающий Future, и не нужна композиция.
Простейшего контракта достаточно.

В современном коде с активной асинхронной композицией вы чаще всего будете пропускать Future и сразу использовать CompletableFuture — но Future — это тип, который ExecutorService по-прежнему возвращает из submit, поэтому вы встретите оба.

`FutureTask` — реализация за `submit`

Класс, который обеспечивает работу submit. Его можно использовать напрямую:

FutureTask<Integer> task = new FutureTask<>(() -> compute());
new Thread(task).start();                              // FutureTask is a Runnable
Integer v = task.get();

Большинство кода не создаёт FutureTask напрямую — это делает инфраструктура исполнителей. Но он полезен, когда нужен объект, одновременно являющийся Future и Runnable — например, для планирования на чём-то отличном от ExecutorService.

Практический пример: submit, тайм-аут, передача исключений

Программа ниже отправляет медленную, быструю и падающую задачи; демонстрирует get, get(timeout), распаковку исключений и отмену.

java— editable, runs on the server

import java.io.IOException;
import java.util.concurrent.*;

public class CallableFutureDemo {
  public static void main(String[] args) throws Exception {
    try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
      // 1. Basic: submit a Callable, get the value
      System.out.println("1. Basic Future.get():");
      Future<Integer> f1 = pool.submit(() -> {
        Thread.sleep(50);
        return 42;
      });
      System.out.println("   value = " + f1.get());

// 2. Timeout: pull the eject lever after 100 ms
      System.out.println("\n2. Future.get with timeout (task takes 500 ms):");
      Future<Integer> slow = pool.submit(() -> {
        try { Thread.sleep(500); }
        catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          System.out.println("   task: caught interrupt, bailing");
          throw e;
        }
        return 99;
      });
      try {
        slow.get(100, TimeUnit.MILLISECONDS);
      } catch (TimeoutException e) {
        boolean cancelled = slow.cancel(true);          // interrupt the running thread
        System.out.println("   timed out; cancel(true) returned " + cancelled);
      }
      Thread.sleep(50);                                 // let the cancelled task wind down

// 3. Exception wrapping
      System.out.println("\n3. Task throws — ExecutionException wraps the cause:");
      Future<String> failing = pool.submit((Callable<String>) () -> {
        throw new IOException("upstream not responding");
      });
      try {
        failing.get();
      } catch (ExecutionException e) {
        Throwable cause = e.getCause();
        System.out.println("   cause class:   " + cause.getClass().getSimpleName());
        System.out.println("   cause message: " + cause.getMessage());
      }

// 4. Cancellation of a queued (not yet running) task
      System.out.println("\n4. Cancel an unstarted task:");
      // Saturate the 2-thread pool first
      Future<?> hog1 = pool.submit(() -> { Thread.sleep(200); return null; });
      Future<?> hog2 = pool.submit(() -> { Thread.sleep(200); return null; });
      Future<Integer> queued = pool.submit(() -> 7);    // sits in the queue
      boolean ok = queued.cancel(false);                // can cancel un-started
      System.out.println("   cancel(false) on queued task returned " + ok
          + "; isCancelled=" + queued.isCancelled());
      try {
        queued.get();
      } catch (CancellationException e) {
        System.out.println("   get() on cancelled future throws CancellationException");
      }
      hog1.get(); hog2.get();

// 5. invokeAny — first success wins
      System.out.println("\n5. invokeAny — return first success, cancel rest:");
      var tasks = java.util.List.<Callable<String>>of(
          () -> { Thread.sleep(200); return "slow"; },
          () -> { Thread.sleep(50);  return "fast"; },
          () -> { Thread.sleep(300); return "slowest"; }
      );
      String winner = pool.invokeAny(tasks);
      System.out.println("   winner: " + winner);
    }
    System.out.println("\ndone.");
  }
}

Что нужно вынести из запуска:

Раздел 1 — простейший шаблон: отправить Callable, вызвать get, получить значение. get блокировал главный поток на 50 мс, которые заняла задача. Именно это и делает Future в базовой форме — типизированный, блокирующий дескриптор результата, который придёт позже.
Раздел 2 показал шаблон с тайм-аутом. Медленная задача работала бы 500 мс; get(100, MS) сдался через 100 и выбросил TimeoutException. Следующий cancel(true) прервал выполняющийся поток, чтобы тот мог завершиться досрочно. Без отмены задача продолжала бы выполняться ещё 400 мс — занимая поток, результат которого вам уже не нужен.
Раздел 3 показал обёртку исключений. Callable выбросил IOException; get() перевыбросил его внутри ExecutionException. e.getCause() вернул оригинал. Это универсальный канал сбоев API — любой проверяемый или непроверяемый выброс из тела попадает сюда.
Раздел 4 показал отмену незапущенной задачи. Пока оба потока пула заняты hog1 и hog2, задача queued находилась в очереди; cancel(false) удалила её, так и не запустив. Вызов get() на отменённом future выбросил CancellationException — это отличается от «задача выбросила исключение» (тогда было бы ExecutionException).
Раздел 5 показал invokeAny. Самая быстрая задача (50 мс) победила; остальные две были отменены исполнителем. invokeAny — правильный инструмент для избыточных запросов: обратитесь к нескольким источникам, используйте первый успешный, откажитесь от остальных. Это строительный блок паттерна hedged-request в реальных системах.

Что дальше

Следующая глава, Java CompletableFuture, знакомит с компонуемым асинхронным API — thenApply, thenCompose, allOf, anyOf и десятками комбинаторов, которые превращают Future из однорезультатного дескриптора в полноценный реактивный конвейер.

Практика

Вы вызываете `future.get()`, а задача выбросила `SQLException` из своего метода `call()`. Какое исключение выбросит `get()`?

`ExecutionException`, чей `getCause()` возвращает исходный `SQLException``SQLException` напрямую — `get()` передаёт причину без изменений`RuntimeException`, оборачивающий `SQLException` — проверяемые исключения становятся непроверяемыми на границе`CancellationException`, так как любая упавшая задача автоматически отменяется