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的例子。

1. package com.joy.lession1
2. import scala.concurrent._
3. importExecutionContext.Implicits.global
5. object FutureTestextendsApp{
6. val s ="Hello"
7. val f:Future[String]= future {
8. s +" future!"
9. }
10. f onSuccess {
11. case msg => println(msg)
12. }
13. println(s)//不加这句, f onSuccess就不执行
14. }

Future的apply()方法会构建一个异步操作且在未来某一个时刻返回一个值。Future的apply()方法内部使用了Promise。

 

下面给Future添加一个回调函数。

1. import scala.concurrent._
2. importExecutionContext.Implicits.global
3. import scala.util.{Failure,Success,Try}
5. object FutureTestextendsApp{
6. val s ="Hello"
7. val f:Future[String]= future {
8. s +" future!"
9. }
10. f onComplete {
11. caseSuccess(t)=>
12. {
13. println(t)
14. }
15. caseFailure(e)=>
16. {
17. println(s"An error has occured: $e.getMessage")
18. }
19. }
20. println("dd")
21. }

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字面意思是承诺，以为他可以控制异步操作的结果

1. import java.util.Timer
2. import java.util.TimerTask
4. import scala.concurrent._
6. object TimedEvent{
7. val timer =newTimer
9. /** Return a Future which completes successfully with the supplied value after secs seconds. */
10. def delayedSuccess[T](secs:Int, value: T):Future[T]={
11. val result =Promise[T]
12. timer.schedule(newTimerTask(){
13. def run()={
14. result.success(value)
15. }
16. }, secs *1000)
17. result.future
18. }
20. /** Return a Future which completes failing with an IllegalArgumentException after secs
21. * seconds. */
22. def delayedFailure(secs:Int, msg:String):Future[Int]={
23. val result =Promise[Int]
24. timer.schedule(newTimerTask(){
25. def run()={
26. result.failure(newIllegalArgumentException(msg))
27. }
28. }, secs *1000)
29. result.future
30. }

 

 

 

 

来自为知笔记(Wiz)