Tutorials Hut

Tutorials Hut




  • Scala Future: Blocked calls, callbacks,  onComplete and Global Execution Context

    Future is a concept in Scala to achieve parallelism or concurrency or multi threading in Scala. As we know each and every programming language tries to process faster and run parallel multiple tasks to complete them quicker, similarly Scala has Future to run multiple small tasks in different future code blocks. In this article we will see in detail about Scala’s future and promise.

    Features and Key Points Of Scala Future

    1. Future is used to achieve parallelism in Scala.

    2. In the future each task runs independent and almost parallel.

    3. It helps in making applications faster and completing given tasks quicker.

    4. Future should be written in such a way that it should not be blocked.

    5. It helps in developing asynchronous applications.

    6. It is similar to Java’s threading.

    7. When the future or execution is not complete we call it a complete future.

    8. When the future or execution is complete we call the future is complete.

    9. Whenever we execute code in future it executes the code in thread.

    10.  Based on coding logic we may write blocking or non-blocking code.

    Syntax of Scala Future

    val inverseFuture: Future[<T Type>] = Future {
      // non-blocking long lasting computation returning some T type of data
    }(executionContext)

    Or with the more idiomatic:

    implicit val ec: ExecutionContext = ..
    val inverseFuture : Future[<T type>] = Future {
    // non-blocking long lasting computation returning some T type of data
    } // ec is implicitly passed

    Scala Future Example

    See below future example where we have written a method to do some work and return the future of String. We have used wait to block the call and resolve the future, don’t do this in production, ideally the future should not be blocked until the end of the program where it is really needed. 

    Example:

    import scala.concurrent.Future
    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.concurrent.duration.Duration //It is needed
    import scala.concurrent.Await
    
    object FutureInScala {
    
      def main(args: Array[String]): Unit = {
    
    	val myFutureVal: Future[String] = myFutureMethod()
    
    	println(Await.result(myFutureVal, Duration.Inf))
    
      }
      def myFutureMethod(): Future[String] = Future {
    
    	"Some long running code here, in future"
      }
    }

    Output:

    Some long running code here, in future

    Scala Execution Context, Global execution context

    To execute any future we need a ExeuctionContext, it is similar to thread pools in java, to execute threads in java we create thread pools and then inside we can have multiple threads and may run it. Similarly in Scala we have execution context, Scala by default gives such a pool which is called Global context. Note that Execution context is based on  ForkJoinPool of java.

    Global context is found in below package:

    scala.concurrent.ExecutionContext.Implicits.global.

    It is an implicit and hence once imported no need to pass it explicitly in code.

    Callbacks Using onComplete

    Callbacks are ways to call on future and find the results of future, onComplete is a call back method available in Scala future to resolve the results of future and do some processing on final data.

    Example of Callbacks using onComplete:

    Note in this example at the end we have added thread sleep method, this is just to ensure main thread does not exit before running future, don’t use such code in production. In onComplete we have two results Success or Failure, Success means future resolved and failure means something went wrong, handle the exception.

    import scala.concurrent.Future
    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.util.{Failure, Success}
    object FutureInScala {
    
      def main(args: Array[String]): Unit = {
    
    	val myFutureVal: Future[String] = myFutureMethod()
    
    myFutureVal.onComplete({
      	case Success(data) => println(data)
      	case Failure(exception) => println("Failed some exception")
    	})
    
    	Thread.sleep(500) //This is to ensure main thread does not end before future, dont use in prod code
      }
      def myFutureMethod(): Future[String] = Future {
    	"Some long running code here, in future"
      } 

    Output:

    Some long running code here, in future

    Scala Blocked Call Outside Future Using Await

    In Scala there is Await class and it has methods to wait on future to specified time duration to get the results, if it is over it will give a timeout error.

    Example of Scala Await with Future:

    See println(), inside that we have used Await.result() and passed futured and Duration.Infy to wait infinite time to resolve future, we can provide custom time as well.

    import scala.concurrent.Future
    import scala.concurrent.ExecutionContext.Implicits.global
    import scala.concurrent.duration.Duration //It is needed
    import scala.concurrent.Await
    
    object FutureInScala {
      def main(args: Array[String]): Unit = {
    
    	val myFutureVal: Future[String] = myFutureMethod()
    	println(Await.result(myFutureVal, Duration.Inf))
      }
      def myFutureMethod(): Future[String] = Future {
    	"Some long running code here, in future"
      }
    }

    Output:

    Some long running code here, in future

    Scala Blocked Call Inside Future Using Blocking

    We can use a blocking construct inside future to make a blocking future call, it will be blocked until execution is completed.

    Sample Code:

    implicit val ec = ExecutionContext.fromExecutor(
                    Executors.newFixedThreadPool(4))
    Future {
     blocking { blockingStuff() }
    }

    Reference

    Next Article

    • Scala Interviews

















  • Leave a Reply

    Your email address will not be published. Required fields are marked *

    Scroll to Top