Future в Scala представляет собой контейнер для значения, которое может быть вычислено асинхронно, т. е. в будущем. Он используется для запуска вычислений в фоновом потоке, не блокируя основной поток выполнения. После завершения вычисления Future может содержать либо результат (Success), либо ошибку (Failure). Этот механизм позволяет писать неблокирующий, асинхронный код, особенно полезный при работе с IO, сетевыми запросами или параллельными вычислениями.

Основы работы Future

Чтобы создать Future, необходим импорт ExecutionContext, который предоставляет потоки для выполнения асинхронной работы:

import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future

Создание Future:

val f = Future {
// некий тяжёлый или асинхронный код
Thread.sleep(1000)
42
}

Future начинает выполнение сразу после создания, в другом потоке, предоставленном ExecutionContext.

Получение результата

Вместо блокировки основного потока, как в Thread.join или get, в Scala применяются функциональные методы:

• onComplete

• map

• flatMap

• recover

• recoverWith

Пример onComplete:

f.onComplete {
case Success(value) => println(s"Got result: $value")
case Failure(ex) => println(s"Error: ${ex.getMessage}")
}

Обработка результата: map, flatMap

map — применяется к результату в случае успеха:

val f2 = f.map(_ \* 2) // если f = 42, то f2 = 84

flatMap — позволяет строить цепочки Future:

val f3 = f.flatMap(x => Future(x \* 10))

Обработка ошибок: recover, recoverWith

recover перехватывает ошибку и возвращает значение:

val safe = f.recover {
case \_: ArithmeticException => 0
}

recoverWith возвращает новый Future в случае ошибки:

val safe2 = f.recoverWith {
case \_: ArithmeticException => Future.successful(0)
}

Блокировка (используется с осторожностью)

import scala.concurrent.Await
import scala.concurrent.duration._
val result = Await.result(f, 2.seconds)

Метод Await.result блокирует поток, и его следует избегать в продакшене.

Комбинирование Future

Можно комбинировать несколько Future:

val f1 = Future(10)
val f2 = Future(20)
val combined = for {
a <- f1
b <- f2
} yield a + b

for-comprehension здесь разворачивает Future как монаду.

Обработка нескольких Future

Future.sequence

Преобразует List[Future[A]] → Future[List[A]]:

val futures = List(Future(1), Future(2), Future(3))
val all = Future.sequence(futures)

Future.traverse

Аналог map + sequence:

val data = List(1, 2, 3)
val processed = Future.traverse(data)(x => Future(x \* 2)) // Future(List(2, 4, 6))

Потоки выполнения: ExecutionContext

Future использует ExecutionContext, чтобы запускать работу в фоновом потоке. Обычно применяется global, но можно определить свой пул:

val ec = ExecutionContext.fromExecutor(Executors.newFixedThreadPool(4))
Future { /\* ... \*/ }(ec)

Это важно, когда нужно контролировать количество потоков или обеспечить изоляцию между задачами.

Параллельность и отказоустойчивость

Future удобен для конкурентного программирования. Код на Future остаётся декларативным, поддерживает чистые функции, легко комбинируется и обрабатывается без явного управления потоками.

Ошибки в Future автоматически перехватываются и оборачиваются в Failure, что делает код безопаснее. Обработка исключений происходит через recover, recoverWith, fallbackTo или через onComplete.

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

• Не ленивый: начинает выполнение немедленно.

• Нет отмены: нельзя остановить выполнение.

• Потокобезопасность зависит от используемых структур.

• Не поддерживает backpressure.

• Не подходит для сложных потоков данных с управлением ресурсами.

Альтернативы

• IO (cats-effect) — ленивый, контролируемый, безопасный.

• ZIO — эффект-система с управлением ресурсами и безопасностью типов.

• Akka / Monix Task / FS2 Stream — для продвинутой асинхронности и реактивности.

Пример реального использования:

def fetchUser(id: Int): Future\[User\] = ???
def fetchPosts(user: User): Future\[List\[Post\]\] = ???
val result: Future\[List\[Post\]\] = for {
user <- fetchUser(42)
posts <- fetchPosts(user)
} yield posts

Этот код выполняется асинхронно, не блокируя основной поток, и обрабатывает результат как единый Future.