Scala Future

Future

• scala.concurrent.Future 异步执行代码块

  import java.time._
  import scala.concurrent._
  import ExecutionContext.Implicits.global // 全局线程池
  Future {
          Thread.sleep(10000)
          println(s"This is the future at ${LocalTime.now}")
  }
  println(s"This is the present at ${LocalTime.now}")

• 监听结果（阻塞）

  import scala.concurrent.duration._
  val f = Future { Thread.sleep(10000); 42 }
  val result = Await.result(f, 10.seconds) //阻塞10s
  
  val f = Future { ... }
  Await.ready(f, 10.seconds)
  val Some(t): Option[Try[T]] = f.value
  
  t match {
          case Success(v) => println(s"The answer is $v")
          case Failure(ex) => println(ex.getMessage)
  }

ready()

• 到达等待时间无结果时，会抛出异常 TimeoutException
• 任务抛出的异常时，result() 会再次抛出异常， ready() 可获取结果

• 回调

  val f = Future { 
          Thread.sleep(10000)
          if (random() < 0.5) throw new Exception
          42
  }
  f.onComplete {
          case Success(v) => println(s"The answer is $v")
          case Failure(ex) => println(ex.getMessage)
  }

• 问题：1.回调地狱；2.执行顺序无法预知

  val future1 = Future { getData1() }
  val future2 = Future { getData2() }
  future1 onComplete {
          case Success(n1) =>
                  future2 onComplete {
                          case Success(n2) => {
                                  val n = n1 + n2
                                          println(s"Result: $n")
                                  }
                          case Failure(ex) => ...
                  }
          case Failure(ex) => ...
  }

  将 Future 看作集合

  // val 会立即执行，def 调用时执行
  val future1 = Future { getData1() }
  val future2 = Future { getData2() }
  // 都获取到结果时，才会进行计算
  val combined = for (n1 <- future1; n2 <- future2) yield n1 + n2

• Promise
  • 与 Java 8 中的 CompletableFuture 类似

  • Future 只读，在任务完成时隐式设置结果值；Promise 类似，但结果值可显式设置

    // Future
    def computeAnswer(arg: String) = Future {
        val n = workHard(arg)
        n
    }
    
    // Promise
    def computeAnswer(arg: String) = {
        val p = Promise[Int]()
        Future {
            val n = workHard(arg)
            // 显式设置结果
            p.success(n)
            workOnSomethingElse()
        }
        // 立即返回该 Promise 对应的 Future
        p.future
    }
    
    // 多个任务对应一个 Promise
    val p = Promise[Int]()
    Future {
        var n = workHard(arg)
        // 若 Promise 未完成则接受结果并返回 true；否则忽略结果并返回 false
        p.trySuccess(n)
    }
    Future {
        var n = workSmart(arg)
        p.trySuccess(n)
    }

• 执行上下文
  • 默认执行在全局的 fork-join 线程池（默认大小为核数），适用于计算密集型任务

  • 对于阻塞型/IO密集型的任务，可使用 Java 的 Executors

    // 隐式声明，或者使用 Future.apply 显式声明
    val pool = Executors.newCachedThreadPool()
    implicit val ec = ExecutionContext.fromExecutor(pool)
    
    val f = Future {
        val url = ...
        blocking {
            val contents = Source.fromURL(url).mkString
            ...
        }
    }