Scala 为什么封锁未来被认为是一种不好的做法？

我试图理解这句话背后的理性

ForkJoinPool

背后的思想是连接进程，这是阻塞操作，这是未来和参与者的执行器上下文的主要实现。它对于阻止连接应该是有效的

我编写了一个小型基准测试，在这个非常简单的场景中，老式期货（scala 2.9）的速度似乎要快两倍

@inline
  def futureResult[T](future: Future[T]) = Await.result(future, Duration.Inf)

  @inline
  def futureOld[T](body: => T)(implicit  ctx:ExecutionContext): () => T = {
    val f = future(body)
    () => futureResult(f)
  }

  def main(args: Array[String]) {
    @volatile

    var res = 0d
    CommonUtil.timer("res1") {
      (0 until 100000).foreach {  i =>
       val f1 = futureOld(math.exp(1))
        val f2 = futureOld(math.exp(2))
        val f3 = futureOld(math.exp(3))
        res = res + f1() + f2() + f3()
      }
    }
    println("res1 = "+res)
    res = 0

    res = 0
    CommonUtil.timer("res1") {
      (0 until 100000).foreach {  i =>
        val f1 = future(math.exp(1))
        val f2 = future(math.exp(2))
        val f3 = future(math.exp(3))
        val f4 = for(r1 <- f1; r2 <- f2 ; r3 <- f3) yield r1+r2+r3
        res = res + futureResult(f4)
      }
    }
    println("res2 = "+res)
  }



start:res1
res1 - 1.683 seconds
res1 = 3019287.4850644027
start:res1
res1 - 3.179 seconds
res2 = 3019287.485058338

@inline
def futuresult[T]（future:future[T]）=wait.result（future，Duration.Inf）
@内联
def futureOld[T]（正文：=>T）（隐式ctx:ExecutionContext）：（）=>T={
val f=未来（正文）
（）=>未来结果（f）
}
def main（参数：数组[字符串]）{
@易变的
var res=0d
CommonUtil.timer（“res1”）{
（0到100000）。foreach{i=>
val f1=未来（数学实验（1））
val f2=未来（数学实验（2））
val f3=未来（数学实验（3））
res=res+f1（）+f2（）+f3（）
}
}
println（“res1=“+res”）
res=0
res=0
CommonUtil.timer（“res1”）{
（0到100000）。foreach{i=>
val f1=未来（数学表达式（1））
val f2=未来（数学表达式（2））
val f3=未来（数学表达式（3））
val f4=for（r1未来的大部分要点是，它们使您能够创建可以轻松并行执行的非阻塞并发代码

好的，所以在将来包装一个可能很长的函数会立即返回，这样你就可以推迟担心返回值，直到你真正感兴趣为止。但是如果代码中关心返回值的部分只是阻塞，直到结果实际可用为止，那么你所得到的只是一种使代码稍微整洁的方法ier（你知道，你可以在没有期货的情况下做到这一点——我认为，使用期货整理代码将是一种代码味道）。除非期货中包装的函数非常简单，否则你的代码将花费比计算其他表达式多得多的时间进行阻塞

另一方面，如果您注册一个回调（例如，使用onComplete或onSuccess）并将关心结果的代码放入该回调中，那么您就可以拥有可以组织得非常高效并具有良好伸缩性的代码。它变成事件驱动的，而不必坐在那里等待结果

您的基准测试属于前一种类型，但由于您有一些很小的函数，因此并行执行它们与按顺序执行它们相比几乎没有什么好处。这意味着您主要是在评估创建和访问未来的开销。祝贺您：您表明，在某些情况下，2.9未来更快在做一些比2.10更琐碎的事情时——这些琐碎的事情并没有真正发挥任何一个版本的概念的优势

尝试一些更复杂和要求更高的东西。我的意思是，你几乎马上就要请求未来的值！至少，你可以构建一个100000个期货的数组，然后在另一个循环中提取它们的结果。这将测试一些稍微有意义的东西。哦，让他们根据我

你可以从那里进步到

创建一个对象来存储结果
向每个将来将结果插入对象的对象注册回调
启动n计算
然后，当你要求所有结果时，确定实际结果达到所需的时间。这将更有意义

编辑

顺便说一句，你的基准在自身条件和对正确使用期货的理解上都失败了

首先，您计算的是检索每个未来结果所需的时间，而不是在创建所有3个未来后评估res所需的实际时间，也不是循环迭代所需的总时间。此外，您的数学计算非常简单，您可能实际上正在测试惩罚在第二个测试中，y是a）理解力测试和b）前三个期货被包装的第四个期货

其次，这些总和可能与使用的总时间大致成比例的唯一原因正是因为这里实际上没有并发性

我不是想责骂你，只是基准中的这些缺陷有助于说明问题。对不同未来实现的性能进行适当的基准测试需要非常仔细的考虑。
Java7 docs for reports:

ForkJoinTask是未来的轻量级形式
ForkJoinTasks源于一组限制（仅限于
部分静态可执行）反映其预期用途
计算纯函数或纯函数操作的计算任务
主要的协调机制是fork（），它
安排不继续的异步执行和join（）
直到任务的结果被计算出来。计算应该避免
同步方法或块，并应尽量减少其他阻塞
除了加入其他任务或使用同步器之外的同步
例如，广告宣传与fork/join合作的相位器
任务也不应该执行阻塞IO，应该
理想情况下，访问完全独立于这些变量的变量
被其他正在运行的任务访问。轻微违反这些限制，
例如，使用共享输出流在实践中可能是可以容忍的，
但频繁使用可能会导致性能不佳，并可能导致
如果未等待IO的线程数或
其他外部同步已耗尽。此用法
部分限制是通过不允许检查异常来实施的
例如要抛出的IOException。但是，计算仍然可能
遇到未检查的异常，tha