En todo proyecto o aplicación informática es habitual realizar alguna operación asíncrona, es decir, ejecutar una operación en donde se lanza un mensaje de una operación sin quedarte bloqueado a la espera de su resultado. En la entrada de hoy, «Scala Future con ejemplos», voy a presentar unos ejemplos de utilización de Future desde un punto de vista practico.
Sin ser exhaustivo, podemos definir Future como aquel objeto que contiene un valor el cual estará disponible en algún instante.
La estructura de los ejemplos es incremental en dificultad y los ejemplos que presento son ejemplos que en nuevas versiones del lenguaje pueden presentar diferencias. Los ejemplos son los siguientes:
- Ejemplo 1 básico desde consola
- Ejemplo 2 básico desde consola.
- Ejemplo 3 básico desde consola.
- Ejemplo 4: Future y tratamiento de errores con recover.
- Ejemplo 5: Future y tratamiento de errores con recoverWith.
- Ejemplo 6: Future y ejecución paralela con función fallbackTo.
- Ejemplo 7: Future y ejecución paralela con función zip.
- Ejemplo 8: Future y ejecución paralela con for comprehension.
- Ejemplo 9: Tratamiento de tareas Future para aquella que acabe primero.
Ejemplo 1 básico desde consola
El ejemplo más básico es ejecutar un código en la consola Scala; para ello, arrancamos la consola; insertamos el comando «:paste» y, posteriormente, copiamos el siguiente snippet de código finalizando con Ctrl- D.
El ejemplo define un Future en el cual se lanza una excepción; una vez recibida el resultado, se escribe por la salida estándar.
import scala.concurrent._
import ExecutionContext.Implicits.global
val futureFail = Future { throw new Exception("Error!") }
futureFail.foreach( value => println("->" + value) )
La salida de la ejecución es la siguiente:
import scala.concurrent._ import ExecutionContext.Implicits.global futureFail: scala.concurrent.Future[Nothing] = Future(Failure(java.lang.Exception: Error!))
Ejemplo 2 básico desde consola
Continuamos con la consola y, en este segundo ejemplo, el snippet del código se centra
en la gestión del resultado del Future con la función onComplete y los objetos Success
y Failure. El código es el siguiente:
import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
val futureFail = Future {
throw new Exception("Error!")
}
futureFail.onComplete {
case Success(value) => println("Success:" + value)
case Failure(e) => println("Respuesta Failure:" + e)
}
La salida de la ejecución es la siguiente:
import scala.util._ import scala.concurrent._ import ExecutionContext.Implicits.global futureFail: scala.concurrent.Future[Nothing] = Future(<not completed>) Respuesta Failure:java.lang.Exception: Error!
Ejemplo 3 básico desde consola
La funcionalidad de un Future puede ser una función completa y, en su definición funcional, podemos utilizar funciones, o bien, definir Future en funciones.
En el presente snippet, se definen dos funciones que ejecutan Future: getEvent y getTraffic; además, se define una secuencia de ejecución de Future empleando las funciones anteriores: futureStep1 y futureStep2; el resultado de la ejecución de la secuencia, lo realiza futureStep2 el cual controla el resultado empleando objetos Success y Failure.
import scala.util._
import scala.concurrent._
import ExecutionContext.Implicits.global
def getEvent(parametro: String): Future[String] = {
val resultadoGetEvent = Future{
val resultado = "getEvent: " + parametro
resultado
}
resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
val resultadoGetTraffic = Future {
val resultado = "getTraffic: '" + parametro + "'"
resultado
}
resultadoGetTraffic
}
val futureStep1: Future[String] = getEvent("PruebaEvent")
val futureStep2: Future[String] = {
futureStep1.flatMap { response =>
getTraffic(response)
}
}
futureStep2.onComplete {
case Success(value) => println("futureStep2 Success:" + value)
case Failure(e) => println("futureStep2 Failure:" + e)
}
La salida de la ejecución es la siguiente:
import scala.util._ import scala.concurrent._ import ExecutionContext.Implicits.global getEvent: (parametro: String)scala.concurrent.Future[String] getTraffic: (parametro: String)scala.concurrent.Future[String] futureStep1: scala.concurrent.Future[String] = Future(Success(getEvent: PruebaEvent)) futureStep2: scala.concurrent.Future[String] = Future(<not completed>)
Ejemplo 4: Future y tratamiento de errores con recover
Supongamos que en las funciones getEvent y getTraffic se producen errores; dichos errores, tenemos que controlarlos y, en el caso que se produzcan, tenemos que retornar un valor determinado; para estos casos, empleamos la función recover.
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val timeout = Timeout(2 seconds)
case class Resultado(evento: String, traffic: String)
def ejemplo1(): Unit = {
def getEvent(parametro: String): Future[String] = {
val resultadoGetEvent = Future {
val resultado = "getEvent: " + parametro
println(resultado)
resultado
}.recover {
case e: Exception => "Valor getEvent por defecto"
}
resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
val resultadoGetTraffic = Future {
val resultado = "getTraffic: '" + parametro + "'"
println(resultado)
resultado
}.recover {
case e: Exception => "Valor getTraffic por defecto"
}
resultadoGetTraffic
}
val resultadoFutures = for {
event <- getEvent("Parametro")
traffic <- getTraffic(event)
} yield {
Resultado(event, traffic)
}
val result = Await.result(resultadoFutures, timeout.duration)
println(s"->${result}")
}
La salida de la ejecución es la siguiente:
getEvent: Parametro getTraffic: 'getEvent: Parametro' ->Resultado(getEvent: Parametro,getTraffic: 'getEvent: Parametro')
Ejemplo 5: Future y tratamiento de errores con recoverWith
El ejemplo anterior controla los errores pero, ¿qué hacemos cuando una excepción puede ser un resultado esperado?, o bien, ¿qué hacemos cuando se pueden producir muchos tipos de excepciones y queremos controlar el resultado para cada una de ellas?. En estos casos utilizamos la función recoverWith.
case class Resultado(evento: String, traffic: String)
def ejemplo3(): Unit = {
def getEvent(parametro: String): Future[String] = {
val resultadoGetEvent = Future {
val resultado = "getEvent: " + parametro
println(resultado)
resultado
throw new IllegalArgumentException(s"Error en parametro ${parametro}!")
}.recoverWith {
case ex: IllegalArgumentException => Future.successful(ex.getMessage)
case e: Exception => Future.failed[String](new Exception("Error generico en getEvent"))
}
resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
val resultadoGetTraffic = Future {
val resultado = "getTraffic: '" + parametro + "'"
println(resultado)
resultado
}.recoverWith {
case ex: IllegalArgumentException => Future.successful(ex.getMessage)
case e: Exception => Future.failed[String](new Exception("Error generico en getEvent"))
}
resultadoGetTraffic
}
val resultadoFutures = for {
event <- getEvent("Parametro")
traffic <- getTraffic(event)
} yield {
Resultado(event, traffic)
}
val result = Await.result(resultadoFutures, timeout.duration)
println(s"->${result}")
}
El tratamiento del resultado de la función, se realiza empleando un for comprehension de forma secuencial y la función result de Await espera por la terminación de las dos funciones.
Otra posible opción para el control del resultado es utilizando algo como sigue:
resultadoFutures.onComplete {
case Success(value) => println("Success: #" + value + "#")
case Failure(e) => println("Failure:" + e)
}
La salida de la ejecución es la siguiente:
getEvent: Parametro getTraffic: 'Error en parametro Parametro!' ->Resultado(Error en parametro Parametro!,getTraffic: 'Error en parametro Parametro!')
Ejemplo 6: Future y ejecución paralela con función fallbackTo
En ciertos momentos necesitamos que dos Future se ejecuten de forma paralela. En estos casos, utilizamos la función fallbackTo.
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val timeout = Timeout(2 seconds)
def ejemplo2(): Unit = {
def getEventforma2(parametro: String): Future[String] = {
val resultadoGetEvent = Future {
val resultado = "getEvent: " + parametro
Thread.sleep(2000)
println("->" + resultado)
resultado
}
resultadoGetEvent
}
def getTrafficforma2(parametro: String): Future[String] = {
val resultadoGetTraffic = Future {
val resultado = "getTraffic: '" + parametro + "'"
println("=>" + resultado)
resultado
}
resultadoGetTraffic
}
// Se ejecuta en paralelo el future getEventforma2 y getTrafficforma2
// El resultado será el resultado del primer future que termine.
// El Await espera a que terminen los dos Future.
val futureResultado = getEventforma2("PruebaEvent") fallbackTo getTrafficforma2("PruebaTraffic")
val resultado = Await.result(futureResultado, timeout.duration)
println(s"->$resultado")
}
Un posible solución puede ser la siguiente pero, en función del tiempo de ejecución, se puede producir una excepción de tipo TimeoutException.
=>getTraffic: 'PruebaTraffic' ->getEvent: PruebaEvent ->getEvent: PruebaEvent
Ejemplo 7: Future y ejecución paralela con función zip
Otra forma de ejecutar Future en paralelo es utilizando la función zip y, con esta función, al terminar cada una de las funciones, realizar el tratamiento. El siguiente ejemplo muestra un ejemplo de uso.
def ejemplo1(): Unit = {
case class Resultado(aEvent:String, aTraffic:String)
def getEvent(parametro: String): Future[String] = {
val resultadoGetEvent = Future {
val resultado = "getEvent: " + parametro
println(s"getEvent=${resultado}")
Thread.sleep(3000)
resultado
}
resultadoGetEvent
}
def getTraffic(parametro: String): Future[String] = {
val resultadoGetTraffic = Future {
val resultado = "getTraffic: '" + parametro + "'"
println(s"getTraffic=${resultado}")
resultado
}
resultadoGetTraffic
}
val resultado = (getEvent("param1") zip getTraffic("param2")) map {
case (event, traffic) => {
println("#event=" + event + " #traffic=" + traffic)
Resultado(aEvent=event, aTraffic=traffic)
}
}
val result = Await.result(resultado, timeout.duration)
println("resultado forma1=" + result)
}
La salida de la ejecución del código es la siguiente:
getTraffic=getTraffic: 'param2' getEvent=getEvent: param1 #event=getEvent: param1 #traffic=getTraffic: 'param2' resultado forma1=Resultado(getEvent: param1,getTraffic: 'param2')
Ejemplo 8: Future y ejecución paralela con for comprehension
El objeto Future es de tipo monádico con lo cual podemos emplear for comprehension de la siguiente forma:
def ejemplo2(): Unit = {
case class ResultadoMonada(tarea1: String, tarea2: String)
def getTareaAsincrona1(): String = {
val resultadoTarea = "Hacemos una tarea asíncrona1"
Thread.sleep(2000)
resultadoTarea
}
def getTareaAsincrona2(): String = {
val resultadoTarea = "Hacemos una tarea asíncrona2"
resultadoTarea
}
val getTareaAsincrona1Future = Future {
getTareaAsincrona1()
}
val getTareaAsincrona2Future = Future {
getTareaAsincrona2()
}
val resultMonada = for {
resultado1 <- getTareaAsincrona1Future
resultado2 <- getTareaAsincrona2Future
} yield {
ResultadoMonada(tarea1 = resultado1, tarea2 = resultado2)
}
val result = Await.result(resultMonada, timeout.duration)
println("resultado Monada=" + result)
}
La salida de la ejecución del código es la siguiente:
resultado Monada=ResultadoMonada(Hacemos una tarea asíncrona1,Hacemos una tarea asíncrona2)
Ejemplo 9: Tratamiento de tareas Future para aquella que acabe primero
Hay necesidades funcionales en las cuáles necesitamos lanzar varias tareas y tratar aquel Future cuya ejecución termine el primero, despreciando al resto. En estos casos, empleamos la función firstCompletedOf. En el siguiente ejemplo, tomando las funciones del apartado anterior, el tratamiento del primer Future en terminar sería el siguiente:
// Arranca la tareaProgramada después de 200 milisegundos
val tareaProgramada1 = after(200 millis, using=system.scheduler)(getTareaAsincrona1Future)
val result1 = Future firstCompletedOf(Seq(tareaProgramada1, getTareaAsincrona2Future))
println(s"Resultado Prueba1:${result1}")
Una de las salidas de la ejecución del código anterior es el siguiente:
Success(Hacemos una tarea asíncrona2)
Otra posible codificación puede ser la siguiente:
[...]
// Tratamiento "quien acabe primero": resultado Exception porque future2 tarda mas en terminar.
val tareaProgramada2 = after(200 millis, using=system.scheduler)(Future.failed(new IllegalStateException("error!")))
val future2 = Future { Thread.sleep(1000); "foo" }
val result2 = Future firstCompletedOf(Seq(tareaProgramada2, future2))
result2 onComplete{
case Success(resultado) => println(s"resultado2=${resultado}")
case Failure(error) => println(s"error2=${error}")
}
Al lanzar la tareaProgramada2 una excepción, la salida de la ejecución del código anterior es la siguiente:
error2=java.lang.IllegalStateException: error!
Para finalizar el tipo de ejemplo, otra ejecución puede ser la siguiente:
val tareaProgramada3 = after(200 millis, using=system.scheduler)(Future.failed(new IllegalStateException("error!")))
val future3 = Future { "foo" }
val result3 = Future firstCompletedOf(Seq(tareaProgramada3, future3))
result3 onComplete{
case Success(resultado) => println(s"resultado3=${resultado}")
case Failure(error) => println(s"error3=${error}")
}
La salida del anterior snippet de código es la siguiente:
resultado3=foo
Estos son los ejemplos que presento, si al lector interesado se le ocurre plantear otro ejemplo, o bien, plantear cualquier otra alternativa, estaré encantado de compartirlo.
Álvaro Monsalve Serrano 