En la entrada anterior, «Scala Future con Ejemplos», realicé una descripción de cómo utilizar la entidad Future en Scala con ejemplos. En la presente entrada, «Scala Future con Ejemplos, continuación», realizaré una ampliación de Future y, además, describiré ejemplos de utilización de Future con Actores.
El modelo de actores, segun wikepedia, es un modelo matemático de computación simultánea que trata a los actores como los primitivos universales de la computación concurrete. La implementación que utilizaremos es la que proporciona Akka y voy a suponer que el lector tiene unos conocimientos mínimos del modelo de actores y de Akka. La definición de dependencia de la librería Akka en sbt es la siguiente:
libraryDependencies += "com.typesafe.akka" %% "akka-actor" % akkaVersion,
Para la realización de los siguientes ejemplos, es necesario definir un actor con una mínima funcionalidad. La funcionalidad es la siguiente: si el actor recibe un mensaje de tipo String (msg), el actor responde con la concatenación del contenido de msg con el texto «Recibido en Actor»; si el actor recibe cualquier otro mensaje, el actor responde con el mensaje «Hola Mundo.» La implementación del actor es la siguiente:
import akka.actor.{Actor, Props}
import scala.concurrent.Future
object ActorEjemplo {
def props() = Props(new ActorEjemplo())
}
class ActorEjemplo extends Actor {
import context.dispatcher
def receive = {
case msg:String =>{
val respuesta = msg + " Recibido en Actor"
println(respuesta)
sender() ! respuesta
}
case _ => {
val respuesta = "Hola Mundo"
println(respuesta)
sender() ! respuesta
}
}
}
La lista de ejemplos que se muestran son los siguientes:
- Ejemplo 1: ejemplo de Futures con tratamiento funcional
- Ejemplo 2: ejemplo de Futures con tratamiento funcional
- Ejemplo 3: ejemplo de Futures con tratamiento funcional.
- Ejemplo 4: ejecución de un Actor con tiempo de espera.
- Ejemplo 5: ejecución de un Actor sin tiempo de espera.
- Ejemplo 6: composición de Futures.
- Ejemplo 7: composición de Furures con for comprehension.
- Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]
- Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]
- Ejemplo 10: morfismos con Future, función fold.
- Ejemplo 11: morfismos con Future, función reduce
- Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf
Ejemplo 1: ejemplo de Futures con tratamiento funcional
Sea un Future future1 cuyo resultado sea el texto «Hello world!»; sea el Future future2 cuyo resultado es el valor entero 3; y, por último, sea el Future future3 que define una secuencia de operaciones con futuro1 y future2 para realizar un cálculo numérico a partir de la ejecución secuencial de future1 y future2.
El snippet del código con las ejecución de las tres futuros la solución es la siguiente:
def ejemplo(): Unit = {
val future1 = Future {
"Hello world!"
}
val future2 = Future.successful(3)
val future3 = future1 map { elemf1 =>
future2 map { elemf2 =>
elemf1.length * elemf2
}
}
future3 onComplete {
case Success(resultado) => println(s"resultado ejemplo3=${resultado}")
case Failure(error) => println(s"error ejemplo3=${error}")
}
}
La salida por consola de la ejecución del código anterior es la siguiente:
resultado ejemplo3=Success(36)
Ejemplo 2: ejemplo de Futures con tratamiento funcional
El siguiente ejemplo es el mismo que el caso anterior pero empleando la función foreach.
def ejemplo(): Unit = {
val future1 = Future {
"Hello world!"
}
val future2 = Future.successful(3)
val future3 = future1 flatMap { elemf1 =>
future2 map { elemf2 =>
elemf1.length * elemf2
}
}
future3 foreach { elem => println(s"Resultado ejemplo4=${elem}") }
}
La salida por consola de la ejecución del código anterior es la siguiente:
Resultado ejemplo4=36
Ejemplo 3: ejemplo de Futures con tratamiento funcional
Sean tres Futures cuyo resultado individual son tres operaciones matemáticas simples y, el último Future, define un filtro. El resultado será la multiplicación del segundo por el tercero.
El snippet del código con la solución es la siguiente:
def ejemplo5(): Unit = {
val resultado = for {
a <- Future(10 / 2)
b <- Future(a + 1)
c <- Future(a - 1)
if c > 3
} yield {
b * c
}
resultado foreach { elem => println(s"Resultado ejemplo5=${elem}") }
}
La salida por consola de la ejecución del código anterior es la siguiente:
Resultado ejemplo5=24
Ejemplo 4: ejecución de un Actor con tiempo de espera
El ejemplo siguiente realizará la creación de un actor, envío de un mensaje y el tratamiento de la respuesta del actor con un tiempo de espera; para finalizar, se realizará la eliminación del actor del ejemplo enviándole el mensaje «PoisonPill». La definición del actor es la definida al principio de la entrada y el sistema de actores es el identificado con el identificador «Ejem».
El código del ejemplo es el siguiente:
import scala.concurrent._
import ExecutionContext.Implicits.global
implicit val system = ActorSystem("Ejem")
implicit val timeout = Timeout(2 seconds)
def ejemplo1(): Unit = {
val actorEjemplo1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo1")
val future: Future[Any] = actorEjemplo1 ? "Mensaje"
val result: String = Await.result(future, timeout.duration).asInstanceOf[String]
println(s"\nresultado ejemplo1=${result}")
actorEjemplo1 ! PoisonPill
}
La salida por consola de la ejecución del código anterior es la siguiente:
Mensaje Recibido en Actor resultado ejemplo1=Mensaje Recibido en Actor
La creación del actor se realiza con la función actorOf del sistema de actores identificado como system; el envío de un mensaje a un actor se utiliza la función «?»; y, su resultado, es gestionado por el componente Await el cual opera con la respuesta de tipos Future que retorna el actor.
Ejemplo 5: ejecución de un Actor sin tiempo de espera
El siguiente ejemplo es idéntico que el anterior pero se espera la respuesta del actor de tipo Future sin tiempo de espera. La lógica es la misma que el ejemplo anterior pero se emplea la función onComplete para gestionar el resultado de ejecución. El código del ejemplo es el siguiente:
def ejemplo2(): Unit = {
val actorEjemplo2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo2")
// La función mapTo retorna un nuevo Future con la respuesta si es Success; en otro caso, ClassCastException.
val future: Future[String] = ask(actorEjemplo2, "mensaje").mapTo[String]
future onComplete {
case Success(resultado) => println(s"\nresultado ejemplo2=${resultado}\n")
case Failure(error) => println(s"\nerror ejemplo2=${error}\n")
}
actorEjemplo2 ! PoisonPill
}
Ejemplo 6: composición de Futures.
Supongamos que necesitamos ejecutar dos futuros y, su resultado, es la entrada de un tercer futuro. Una posible solución con un tiempo de espera determinado es la siguiente:
def ejemplo6(): Unit = {
val actorEjemplo6_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-1")
val actorEjemplo6_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-2")
val actorEjemplo6_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo6-3")
val future1 = actorEjemplo6_1 ask ("Mensaje a Actor6_1")
val future2 = actorEjemplo6_2 ask ("Mensaje a Actor6_2")
val respuestaFuture1 = Await.result(future1, 3 seconds).asInstanceOf[String]
val respuestaFuture2 = Await.result(future2, 3 seconds).asInstanceOf[String]
val future3 = actorEjemplo6_3 ask ("##" + respuestaFuture1 + "&" + respuestaFuture2 + "##")
val respuestaFuture3 = Await.result(future3, 3 seconds).asInstanceOf[String]
println(s"resultado ejemplo6=${respuestaFuture3}")
}
La salida por consola de la ejecución del código anterior es la siguiente:
Mensaje a Actor6_1 Recibido en Actor Mensaje a Actor6_2 Recibido en Actor ##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor resultado ejemplo6=##Mensaje a Actor6_1 Recibido en Actor&Mensaje a Actor6_2 Recibido en Actor## Recibido en Actor
Ejemplo 7: composición de Furures con for comprehension
El siguiente ejemplo es el mismo que el caso anterior pero se emplea for comprehensión.
def ejemplo7(): Unit = {
val actorEjemplo7_1 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-1")
val actorEjemplo7_2 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-2")
val actorEjemplo7_3 = system.actorOf(ActorEjemplo.props(), "ActorEjemplo7-3")
val future1 = actorEjemplo7_1 ask ("Mensaje a Actor7_1")
val future2 = actorEjemplo7_2 ask ("Mensaje a Actor7_2")
val future3 = for {
f1 <- future1.mapTo[String]
f2 <- future2.mapTo[String]
c <- ask(actorEjemplo7_3, "##" + f1 + "&" + f2 + "##").mapTo[String]
} yield {
c
}
future3 foreach { resultado => println(s"Resultado ejemplo7=${resultado}") }
}
La salida por consola de la ejecución del código anterior es la siguiente:
Mensaje a Actor7_2 Recibido en Actor Mensaje a Actor7_1 Recibido en Actor ##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor Resultado ejemplo7=##Mensaje a Actor7_1 Recibido en Actor&Mensaje a Actor7_2 Recibido en Actor## Recibido en Actor
Ejemplo 8: conversión de List[Future[A]] -> Future[List[A]]
Supongamos que tenemos una lista de operaciones Futuras del mismo tipo, en nuestro caso, Futuros cuya respuesta son números enteros; y, su procesamiento, puede ser transformado un un único Future. La solución consiste en emplear la función sequence la cual es la encargada de transformar muchos Future en uno único. Así, la solución se define de la siguiente forma:
def ejemplo8(): Unit = {
val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
// Convertimos un List[Future[Int]] en Future[List[Int]] para trabajar con el Future.
// Así, podemos trabajar con la List[Int]
val futureList: Future[List[Int]] = Future.sequence(listaFutures)
println(s"futureList=${futureList}")
val suma: Future[Int] = futureList.map(_.sum)
suma foreach{elem => println(s"Resultado ejemplo8=${suma}")}
}
La salida por consola de la ejecución del código anterior es la siguiente:
Resultado ejemplo8=Success(16)
Ejemplo 9: conversión de Future[List[A]] -> List[Future[A]]
Supongamos que tenemos un único Future y una lista de datos de un determinado tipo que procesar y, su procesamiento, puede ser ejecutado por N Futuros. La solución consiste en emplear la función traverse. El código del ejemplo es el siguiente:
def ejemplo9(): Unit = {
// Convertimos un Future[List[Int]] en List[Future[Int]] para trabajar con el Future.
val futureList1 = Future.traverse((1 to 10).toList)(x => Future(x * 2 - 1))
val resultadoFutureList1 = futureList1.map(_.sum)
resultadoFutureList1 foreach {elem => println(s"Resultado1 de ejemplo9=${elem}")}
val futureList2 = Future.traverse(List(1,3,5))(x => Future(x * 2 - 1))
val resultadoFutureList2 = futureList2.map(_.sum)
resultadoFutureList2 foreach {elem => println(s"Resultado2 de ejemplo9=${elem}")}
}
La salida por consola de la ejecución del código anterior es la siguiente:
Resultado2 de ejemplo9=15 Resultado1 de ejemplo9=100
Ejemplo 10: morfismos con Future, función fold
Supongamos que tenemos un ADT de tipo lista de futuros no bloqueantes y queremos realizar un morfismo sobre dicho ADT; el mecanismos para realizarlo, es utilizar la función fold. El siguiente snippet muestra un ejemplo representativo:
def ejemplo10(): Unit = {
val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
val sumaListaFutures = Future.fold(listaFutures)(0)(_+_)
sumaListaFutures onComplete{
case Success(resultado) => println(s"Resultado ejemplo10=${resultado}")
case Failure(error) => println(s"Error ejemplo10=${error}")
}
}
Ejemplo 11: morfismos con Future, función reduce
La función reduce es como la función fold pero sin valor inicial.
def ejemplo11(): Unit = {
val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
val futureSum: Future[Int] = Future.reduce(listaFutures)(_ + _)
futureSum foreach { elem => println(s"Resultado ejemplo11=${futureSum}") }
}
La salida por consola de la ejecución del código anterior es la siguiente:
Resultado ejemplo11=Success(16)
Ejemplo 12: el primero que termine, se ejecuta; función firstCompletedOf
Supongamos que tenemos una lista de futuros en un ADT de tipo lista; y, a nivel de negocio, solo nos interesa el resultado del primer future que termina; en estos casos, se emplea la función firstCompletedOf. El siguiente ejemplo muestra un ejemplo representativo.
def ejemplo12(): Unit = {
val listaFutures: List[Future[Int]] = List(Future(1), Future(3), Future(5), Future(7))
val futureFirst: Future[Int] = Future.firstCompletedOf(listaFutures)
futureFirst foreach { elem => println(s"Resultado ejemplo12=${futureFirst} elem=${elem}") }
}
Una de las posibles salidas por consola de la ejecución del código anterior es la siguiente:
Resultado ejemplo12=Success(3) elem=3
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 