运维开发网
广告位招商联系QQ:123077622
 
广告位招商联系QQ:123077622

Scala Future

运维开发网 https://www.qedev.com 2020-07-31 15:13 出处:网络 作者:运维开发网整理
Future scala.concurrent.Future 异步执行代码块 import java.time._ import scala.concurrent._ import ExecutionContext.Implicits.global // 全局线程池 Future { Thread.sleep(10000) println(s"This is the

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

扫码领视频副本.gif

0

精彩评论

暂无评论...
验证码 换一张
取 消