scala的futue和promise

异步操作的有两个经典接口：Future和Promise,其中的 Future 表示一个可能还没有实际完成的异步任务的结果，针对这个结果可以添加 Callback 以便在任务执行成功或失败后做出对应的操作，而 Promise 交由任务执行者，任务执行者通过 Promise 可以标记任务完成或者失败。 可以说这一套模型是很多异步非阻塞架构的基础。
scala的Future表示一个异步操作的结果状态，它持有一个值，在未来的某个之间点可用，该值是异步操作的结果,当异步操作没有完成，那么Future的isCompleted为false,当异步操作完成了且返回了值，那么Future的isCompleted返回true且是success, 如果异步操作没有完成或者异常终止，那么Future的isCompleted也返回true但是是failed.scala的Future有一个重要特性，就是他只能被赋值一次，一旦Future对象被赋值了或者设置为异常，那么它会变成不可变的
创建一个Future最简单的方式就是调用future函数：它会启动一个异步操作且返回一个包含了操作结果的。一个future函数完成该值就可以用了，Future[T]的泛型是异步操作结果的类型。下面是一个创建Future的例子。

    package com.joy.lession1
    import scala.concurrent._
    importExecutionContext.Implicits.global
    object FutureTestextendsApp{
    val s ="Hello"
    val f:Future[String]= future {
    s +" future!"
    }
    f onSuccess {
    case msg => println(msg)
    }
    println(s)//不加这句, f onSuccess就不执行
    }

Future的apply()方法会构建一个异步操作且在未来某一个时刻返回一个值。Future的apply()方法内部使用了Promise。
下面给Future添加一个回调函数。
    import scala.concurrent._
    importExecutionContext.Implicits.global
    import scala.util.{Failure,Success,Try}
    object FutureTestextendsApp{
    val s ="Hello"
    val f:Future[String]= future {
    s +" future!"
    }
    f onComplete {
    caseSuccess(t)=>
    {
    println(t)
    }
    caseFailure(e)=>
    {
    println(s"An error has occured: $e.getMessage")
    }
    }
    println("dd")
    }

Future的值不知道什么时候可用，所以需要一种机制来获取异步操作的结果，一种是不停的查看Future的完成状态，另一个采用阻塞的方式，scala提供了第二种方式的支持，使用scala.concurrent.Await,它有两个方法，一个是Await.ready，当Future的状态为完成时返回，一种是Await.result，直接返回Future持有的结果。Future还提供了一些map,filter,foreach等操作
 
Scala的Promise可以被认为一个是可写的，静态单赋值，它可以创建一个Future和完成一个Future(success complete和failed complete） promise字面意思是承诺，以为他可以控制异步操作的结果

    import java.util.Timer
    import java.util.TimerTask
    import scala.concurrent._
    object TimedEvent{
    val timer =newTimer
    /** Return a Future which completes successfully with the supplied value after secs seconds. */
    def delayedSuccess[T](secs:Int, value: T):Future[T]={
    val result =Promise[T]
    timer.schedule(newTimerTask(){
    def run()={
    result.success(value)
    }
    }, secs *1000)
    result.future
    }
    /** Return a Future which completes failing with an IllegalArgumentException after secs
    * seconds. */
    def delayedFailure(secs:Int, msg:String):Future[Int]={
    val result =Promise[Int]
    timer.schedule(newTimerTask(){
    def run()={
    result.failure(newIllegalArgumentException(msg))
    }
    }, secs *1000)
    result.future
    }