但是脚本可能仍然会在onComplete处理程序启动之前退出（因为根据定义，它们发生在将来完成之后）。如果使用Await.result，则不再需要onComplete。这样，您只需匹配结果即可。 import scala.concurrent.Execut

---

但是脚本可能仍然会在onComplete处理程序启动之前退出（因为根据定义，它们发生在将来完成之后）。如果使用

Await.result，则不再需要
onComplete
。这样，您只需匹配结果即可。
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")

}

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)
  }
}

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);
}

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 ) )

}

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))

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()
}