Why does my simple scala object hangs for a minute or so while it includes a future

Question

I am learning scala futures and I hit my question already. I have a very simple example

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{Failure, Success}
/**
 * Created by dummy on 05/02/15.
 */
object FutureUtils extends App{

  val f = Future {
    Thread.sleep(1000)
    println("I am learning scala futures")
    "learning"
  }

  f onComplete {

    case Success(value:String) => println("got the response back")
    case Failure(t: Throwable) => println("did not expect this")

  }

  println("I am still learning")

}

When I run the program as-is output never prints

got the response back

instead looks like it hangs for a minute or so and ends without printing the expected output ever. I am sure I am missing something very basic here.

I also tried adding System.in.read() at the end and it seems when I input any dummy value, programs ends printing expected result. What is the reason behind this behavior? Could anyone please help me understand this?

Answer 1

The reason the program doesn't work without the System.in.read() is that onComplete does not block until the future completes but merely adds a callback for when it does. That callback never gets executed because the whole program ends before the future completes. To fix this problem, you could deliberately let the main thread go into an infinite loop and explicitly terminate the process in the callback.

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{Failure, Success}

object Main extends App {
  val f = Future {
    Thread.sleep(1000)
    println("I am learning scala futures")
    "learning"
  }
  f onComplete {
    case Success(value:String) => println("got the response back"); System.exit(0)
    case Failure(t: Throwable) => println("did not expect this"); System.exit(1)
  }
  println("I am still learning")
  while (true){
    Thread.sleep(1000)
  }
}

Answer 2

You need to await the future, the program is exiting before it completes.

import scala.concurrent.Await
import scala.concurrent.duration._

var myFuture = Future {
    Thread.sleep(1000)
    1
}

// oncomplete handlers, etc here

println(Await.result(myFuture, 5 seconds))

EDIT: If you must use onComplete and can't verify that those handlers are executed before Await.ready/result then you should use formal synchronization, i.e.:

import scala.concurrent._
import java.util.concurrent.CountDownLatch

object Main extends App {
  val f = Future {
    Main.synchronized {
      Thread.sleep(1000);
      1
    }
  }

  val latch = new CountDownLatch(1)

  f.onComplete {
    case _ => { latch.countDown() }
  }

  latch.await()
}

Answer 3

Well... since you are sleeping for 1000 miliseconds inside your future, your future will take at least 1 second to complete. The app thread completes itself and exits in this time.

You have to make sure that the app thread is alive when the future completes. You can do this by sleeping in your app thread for some time... like this.

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{Failure, Success}

object FutureUtils extends App{

  val f = Future {
    Thread.sleep(1000)
    println("I am learning scala futures")
    "learning"
  }

  f onComplete {
    case Success(value:String) => println("got the response back")
    case Failure(t: Throwable) => println("did not expect this")
  }

  // Wait for some time
  // Not sure future will complete in this time or not
  Thread.sleep(1000);
  Thread.sleep(1000);
  Thread.sleep(1000);
}

But, the better way to do this is by making it so that the app thread needs the future to complete.

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._
import scala.util.{ Failure, Success }

object FutureUtils extends App {

  val f = Future {
    Thread.sleep( 1000 )
    println( "I am learning scala futures" )
    "learning"
  }

  f onComplete {
    case Success( value:String ) => println( "got the response back" )
    case Failure( t: Throwable ) => println( "did not expect this" )
  }

  while ( f.value == None ) {
    // Waste time just till the future is complete.
  }

  // Do something with future value.
  f.foreach( ( s: String ) => println( s ) )

}