scala - Scala 中多个 Futures 的奇怪案例

Question

Scala 中那些与 Future 相关的类和特征之间有什么联系，为什么它们散布在不同的包中？

我找到了那些:

abstract class scala.actors.Future
object         scala.actors.Futures
trait/object   scala.collection.parallel.FutureThreadPoolTasks
trait          scala.concurrent.FutureTaskRunner
trait          scala.parallel.Future    (the package consists of only this file...)

它们是显着不同的东西还是有其他原因无法合并它们？

有没有一个很好的例子来说明什么时候会使用一种东西或另一种东西？

编辑:奖金用于解释每个类/特征/对象的作用以及它们如何证明它们的存在/它们如何有用。

Answer 1

scala.actors._abstract class Future
首先，让我们看看文档是怎么说的:

A function of arity 0, returing a value of type T that, when applied, blocks the current actor (Actor.self) until the future's value is available.

这基本上就是全部。如果您从另一个 actor 之外的任何地方与一个 actor 通信(它可以简单地使用另一个消息接收对消息的异步回复，使用 sender 引用)并且您需要对已发送消息的回复，您有两种选择:

发送阻塞消息，等待 Actor 完成计算您的结果

使用返回 Future 的方法发送消息，并仅在您确实需要相关值时才阻止该 Future(那时可能已经计算了)

因此， Future 是尚不存在但可能在不久的将来存在的值的占位符。以下内容也很有趣:

A future can be queried to find out whether its value is already available without blocking [using "isSet"].

这允许你做任何你想做的事情，直到你需要的值被计算/获取，你可以定期检查该值是否可用。

在深入研究 Scala 库源代码时，我发现 Futures 实际上只是 Actor 。 Future本身是一个 abstract class ，由 private class FutureActor 扩展.最后一个类是实际实现 Future 的类。 - 功能。
object Futures object Futures到目前为止还没有那么有趣，因为它只是“操作 future 的方法”的容器，方便的工厂方法 future它异步评估传递的块，返回表示结果的 future 。一个小例子是这样的:

import scala.actors.Futures
val f = Futures.future {
    println("Start: inside block")
    val s = System.currentTimeMillis
    while(System.currentTimeMillis < (s + 1000)) {
        // Simulate computation
    }
    println("Start: end of block")
    42
}
println("After future")
println(f())
println("The end")

这应该导致类似

Start: inside block
After future
Start: end of block
42
The end

这表明 future -call 不会阻塞以下代码，直到您实际尝试检索 future 的值(请注意，输出是 non-deterministic 。 After future 也可能出现在输出的开头)。
scala.collection.parallel
这个包是 Scala 2.9.x 的新包，它为我们最喜​​欢的一些集合实现了并行对应物。这些都是以 Par开头的:

ParIterable

ParSeq

ParSet

ParMap

正如您可能已经知道或猜到的那样，这些集合以并行方式实现所有可能的操作，而您不必担心。一个小示范:

(1 to 10).par.map { b => print(b + " "); b * b }
3 1 6 2 7 4 5 9 10 8
    # => (1, 4, 9, 16, 25, 36, 49, 64, 81, 100)

结果将始终相同，但处理元素的顺序又是不确定的。此外，如果您使用的是多核系统，对于较大的集合，您可能会体验到不错的性能提升。
trait FutureThreadPoolTasks FutureThreadPoolTasks trait 扩展了 Tasks trait，所以让我们先来看看那个。特质上面的评论说:

A trait that declares task execution capabilities used by parallel collections.

从其他来源评论和 Tasks中找到的方法来看trait，一个 Task 代表一个需要计算的工作单元。根据问题是否可以进一步分割，如果有更多可用资源，任务可以通过创建更多任务来进一步拆分任务。

现在 FutureThreadPoolTasks trait 本身只是一种计算任务的方法，它使用 java.util.concurrent.Future类为其同步，即它 不使用 scala.actors.Future !从来源:

An implementation of tasks objects based on the Java thread pooling API and synchronization using futures.

object FutureThreadPoolTasks
再次不是很壮观，只是一个包含几个(实际上只有三个)实用方法的伴生对象，其中 FutureThreadPoolTasks特质使用。
scala.concurrent
关于这些类的文档真的很糟糕，而且显然很少有(我没有找到一个)示例来演示这些类的用法。我一定会尝试收集更多关于这些的信息，并尽快扩展这一部分!
scala.parallel trait Future
这似乎是一个“进行中的工作”，如 scala.parallel包仅包含此特征。据我所知，这将与 Future 有关。不使用的实现 Actors ，但这只是一个猜测。特征的签名如下

trait Future[@specialized +R] extends (() => R)

我什至不想解释 the @specialized annotation或 variances (泛型 R 类型之前的 +)，但这个特性的基本思想是 Future 是一个函数，当执行时，返回值(如果尚未计算，则必须因此阻塞)。

此外，特征本身只有两个方法， apply和 isDone .我的猜测是 isDone ，就像 scala.actors.Future.isSet , 应该是一个非阻塞调用，以查看是否已经计算了该值，而 apply方法应该用于实际检索值。