Scala的futue和promise

scala的future和promise

异步操作的有两个经典接口:FuturePromise,其中的 Future 表示一个可能还没有实际完成的异步任务的结果,针对这个结果可以添加 Callback 以便在任务执行成功或失败后做出对应的操作,而 Promise 交由任务执行者,任务执行者通过 Promise 可以标记任务完成或者失败。 可以说这一套模型是很多异步非阻塞架构的基础。

scala的Future表示一个异步操作的结果状态,它持有一个值,在未来的某个之间点可用,该值是异步操作的结果,当异步操作没有完成,那么FutureisCompletedfalse,当异步操作完成了且返回了值,那么FutureisCompleted返回true且是success, 如果异步操作没有完成或者异常终止,那么FutureisCompleted也返回true但是是failed.

scala的Future有一个重要特性,就是他只能被赋值一次,一旦Future对象被赋值了或者设置为异常,那么它会变成不可变的

创建一个Future最简单的方式就是调用future函数:它会启动一个异步操作且返回一个包含了操作结果的。一个future函数完成该值就可以用了,Future[T]的泛型是异步操作结果的类型。下面是一个创建Future的例子。

package com.joy.lession1
import scala.concurrent._
import ExecutionContext.Implicits.global
object FutureTest  extends App{
  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._
import ExecutionContext.Implicits.global
import scala.util.{Failure, Success, Try}
object FutureTest  extends App{
  val s = "Hello"
  val f: Future[String] = future {
    s + " future!"
  }
    f onComplete {
      case Success(t) =>
      {
        println(t)
      }
      case Failure(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 completefailed complete) promise字面意思是承诺,以为他可以控制异步操作的结果

import java.util.Timer
import java.util.TimerTask
import scala.concurrent._
object TimedEvent {
  val timer = new Timer
  /** 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(new TimerTask() {
      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(new TimerTask() {
      def run() = {
        result.failure(new IllegalArgumentException(msg))
      }
    }, secs * 1000)
    result.future
  }






发表于: 1年前   最后更新时间: 1年前   游览量:1532
上一条: ScalaTest详解
下一条: Scala Seq和Set

评论…


  • 评论…
    • in this conversation