La concurrencia y la programación asíncrona son fundamentales para crear aplicaciones eficientes y escalables en un entorno moderno. Scala ofrece herramientas avanzadas, como Futures, Promises, y el modelo de actores, para manejar estas necesidades de manera elegante y segura.

Concurrencia con Future

Un Future representa un cálculo que puede completarse en algún momento en el futuro, ya sea con un resultado exitoso o con un error.

Creación de un Future

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

val futuro = Future {
  Thread.sleep(1000) // Simula una operación costosa
  42
}

futuro.foreach(resultado => println(s"Resultado: $resultado"))

• ExecutionContext: Proporciona el contexto donde se ejecutan los Future. Usualmente es un pool de hilos.
• foreach: Maneja el valor completado de un Future.

Combinación de Futures

Puedes combinar múltiples Future para manejar dependencias entre operaciones concurrentes.

Usando flatMap y map

val futuro1 = Future { 10 }
val futuro2 = Future { 20 }

val suma = for {
  x <- futuro1
  y <- futuro2
} yield x + y

suma.foreach(resultado => println(s"Suma: $resultado"))

Manejo de Errores

Usa recover o recoverWith para manejar fallos en un Future.

val fallo = Future {
  throw new RuntimeException("Error")
}

fallo.recover {
  case e: RuntimeException => println(s"Recuperado de: ${e.getMessage}")
}

Promise

Un Promise es un contenedor que permite completar manualmente un Future asociado.

Ejemplo de Promise