Los futures en Scala son una serie de alternativas de comandos que se emplean como parte de este lenguaje de programación tan popular y demandado dentro del mundo Big Data. De hecho, los futures en Scala se presentan según diversas categorías de los macrodatos y el interés del tratamiento de los macrodatos.
El desarrollo Big Data requiere de estas dinámicas y procesos que optimizan el desenvolvimiento de un estudio ágil y eficaz de los macrodatos. Por ello, si lo que buscas es saber identificar cuál es la mejor herramienta para un análisis de datos específico, contar con este saber es de suma importancia. Así, debido a su relevancia, en este post te explicamos qué son los futures en Scala y cuáles son sus categorías.
¿Qué son futures en Scala?
Los futures en Scala hacen referencia a la aglomeración de comandos y alternativas de un future, es decir, de un valor que puede o no encontrarse en el momento de establecer el comando, pero que, sin embargo, se sabe que en algún momento estará disponible.
De ahí viene su nombre de futuro o futures en Scala, puesto que cuenta con un valor a futuro y no en la actualidad. En suma, esta estrategia ofrece una amplia serie de posibilidades que podrás emplear de forma paralela o separada, según tus intereses.
A continuación, te compartimos cómo se comportan cada una de esas posibilidades de futures en Scala:
Future [T]
Por defecto, las operaciones sin bloqueo tendrán un valor T en algún momento. De manera que te podrás encontrar con que los futures en Scala pueden estar incompletos, es decir, que todavía no tiene valor. O, por el contrario, también puedes hallar un future completo.
Por otra parte, la finalización se tratará como un valor scala.util.Try., lo que quiere decir que tendrá dos valores posibles, que son:
- Success(t: T)
- Failure(t: Throwable)
Future [T] I
import scala.concurrent._
import ExecutionContext.Implicits.global
val firstPrimeNumbers: Future[List[Int]] = Future {
List(1, 2, 3, 4, 7, 11, 13)
// what if ‘calculateFirstPrimeNumbers(100000000000)’
}
val thisWillFail: Future[Int] = Future(2 / 0)
Execution context
Un futuro, una vez que se completa, nunca cambia de valor.
- Se desarrolla en un contexto de ejecución.
- Está diseñado para ejecutar las tareas que se les envían.
- Estos se pueden ver como grupos de subprocesos.
- La mayoría de las operaciones futuras requieren un ExecutionContext implícito.
Future: Catch results
En Catch results o resultados esperados podrás encontrar dos posibilidades:
- Modo bloqueador (discutido, pero a veces obligatorio).
- Manera sin bloqueo: se genera al usar devoluciones de llamada de los datos.
Future: Blocking – Await
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(10000)
2
}
println(Await.result(f, 12 seconds))
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(10000)
2
}
println(Await.result(f, 5 seconds)) =>
java.util.concurrent.TimeoutException
Future: Callbacks
import scala.concurrent._
import ExecutionContext.Implicits.global
val f: Future[Int] = Future {
Thread.sleep(1000)
2
}
f.onComplete(n => println(n))
Future: Callbacks I
- onComplete
- onSuccess/foreach
- onFailure
Future: map & flatMap
def getFirstMillionOfPrimes(): Future[List[Int]] = ???
getFirstMillionOfPrimes().map(
(list: List[Int]) => list.head
) //Future[Int]
def concatenate(l: List[Int]): Future[String] = ???
getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list))
) //Future[String]
Recover & RecoverWith
val f: Future[Int] = Future {
1 / 0
}.recover {
case e: ArithmeticException => 0
}
val f2: Future[Int] = Future {
1 / 0
}.recoverWith {
case e: ArithmeticException => Future(0)
}
Futures: For Comprehension
getFirstMillionOfPrimes().flatMap(
(list: List[Int]) => concatenate(list))
) //Future[String]
is equal to:
for {
primes <- getFirstMillionOfPrimes()
primeString <- concatenate(primes)
} yield primeString
Por medio de este post, te has podido familiarizar con qué son y cómo funcionan los futures en Scala. Sin embargo, debes tener en cuenta que todas estas funciones o comandos que puedes emplear requieren de una gran disciplina para llevarlos a la práctica. Este es, sin duda, el factor más importante para manejar este lenguaje de programación, de manera que ¡debes dar el siguiente paso en Big Data con Scala!
Por este motivo, desde KeepCoding te ofrecemos nuestro Bootcamp Full Stack Big Data, Inteligencia Artificial & Machine Learning. Por medio de este bootcamp, podrás aprender más acerca de cómo configurar un Hive y del Big Data en general con módulos como el de Big Data Architecture, en el que verás una pintura completa del proceso de ingesta, clasificación, resguardo, procesamiento y presentación de los datos utilizando diferentes herramientas, sistemas y lenguajes. Además, podrás instruirte tanto de forma teórica como práctica y en remoto desde cualquier sitio. ¡No esperes más y apúntate ahora mismo!
