Future Promise  异步非阻塞

Future用于获取异步任务的返回结果
Future 两种状态
完成 completed 和 未完成 not completed


完成状态的Future可能包含两种情况
异步任务执行成功，Future中包含返回结果
异步任务执行失败，Future中包含相应的Exception信息

Future 的值只能被写入一次，之后不可变 ，其中包含成功或失败信息
可以在Future上注册回调函数，在任务执行完成后得到通知

scala.concurrent.Future

// 隐式的ExecutionContext 线程池 
// 提供一个默认的线程池来异步执行Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent._

val f = Future{ 
Thread.sleep(1000)
1 + 2 
}

f.onComplete{ t =>
  t match{
    case Success(v) => println("success: " + v)
    case Failure(t) => println("failed: " + t.getMessage)
  }
}

// 可注册多个 ,执行顺序不保证
f.onComplete{
   case Success(v) => println("success2: " + v)
   case Failure(v) => println("failed2: " + v.getMessage)
}

onComplete 非阻塞的通知

Await.result 同步获取结果，或者超时或者异常
Await.ready 等待计算完成，不返回结果

Await.ready(f, 2 seconds)
val result = Await.result(f,Duration.Inf)
Await.result(f,1 seconds)


Future 是一个容器类，使用for取值
val f = Future{ 1 + 2 }
for(v <- f) {
    println(v) // 3
}

val f1 = Future{ 1 + 2 }
val f2 = f1.map(_*2)
for(v <- f2) {
    println(v) // 6
}


for 等待多个Future 返回结果

val f1 = Future{ 1 + 2 }
val f2 = Future{ 3 + 4 }
for{
    v1 <- f1
    v2 <- f2
} {
    println(v1 + v2) // 10
}

yield 返回一个新的Future

val f1 = Future{ 1 + 2 }
val f2 = Future{ 3 + 4 }
val f3 =  
    for{
        v1 <- f1
        v2 <- f2
    } yield {
        v1 + v2
    }
    
for(v <- f3) println(v)



Promise

精细地控制Future的完成时机和返回结果
使用 Promise.success Promise.failure Promise.complete() 来控制 
每个Promise实例都会有一个唯一的Future与之相关联

def hello(name:String):Int = {
  if(name=="xxx") throw new Exception("bad name")
  return 0
}
val helloPromise = Promise[Int]()
val helloFuture = helloPromise.future
helloFuture.onComplete{
   case Success(v) => println("success value ="+v)
   case Failure(e) => println("Failure "+e)
}

// helloPromise.success(hello("cat"));
// helloPromise.success(hello("xxx"));
helloPromise.complete(Try(hello("xxx")))
    


例子代码
https://gitee.com/dyyx/hellocode/blob/master/demo/scala/scalademo/src/main/java/demo/FutureDemo.scala