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
            ...
        }
    }