为什么我们需要 Future 和 Promise？

Question

据我所知，Future 是只读的，Promise 是一次写入数据结构。

我们需要一个Promise 来完成一个Future

例如，

object Lie extends Throwable

val lie = Future { throw Lie } 

val guess = Promise[String]()     

lie.onComplete { case Success(s) => guess.success("I knew it was true!") 
                 case Failure(t) => guess.failure("I knew it was lie")} 
// return type: Unit 

guess.future.map(println) 
// res12: scala.concurrent.Future[Unit] = List()
// I knew it was lie!
// Requires Promise to chain Future with exception 

但是，我不明白为什么我们需要同时拥有 Future 和 Promise

我猜Promise 是必需的，因为Future.onComplete 签名

由于Future.onComplete 返回类型为Unit，Future 可能的异常不能被链接

我假设引入 Promise 是为了克服这个限制

但是为什么不直接更改 Future.onComplete 的签名呢？

将Future.onComplete 的返回类型更改为Future[T] 将启用Future 上的链接，但有异常

然后，Future 不需要Promise

比如上面的代码可以改成

val lie = Future { throw Lie } 

lie.onComplete { 
   case Success(s) => "I knew it was true!"
   case Failure(t) => "I knew it was lie!"
}.map(println) 

//onComplete return type is Future[String]

我的问题是

1) 我说的对吗？ Future 不需要Promise ，如果onComplete 签名从Unit 更改为Future[T]？

2) 为什么 Future 和 Promise 首先是分开的？

UDPATE

感谢回复者，现在我明白了 Promise 的目的。它实际上不是用于Future 链接

如果可以，我可以问你吗

为什么onComplete 返回Unit ??

它实际上可以返回Future[T] 以轻松启用链接Future

例如

Future { throw Error }.onComplete {
  case Success(s) => "Success" 
  case Failure(t) => throw Error
}.onComplete {
  case Success(s) => "Success"
  case Failure(t) => throw Error 
}. ... 

Answer 1

Future.apply[T](block: => T): Future[T] 是Future.unit.map(_ => block)[1] 的语法糖

Future 代表一个值，它可能当前可用也可能不可用。

Promise 表示有义务在某个时候提供这样的值。

为Future（用于读取）和Promise（用于写入）拥有单独的实体意味着很容易推断功能：

• 当 Future 是一个参数时，它是一个在某个时间点具有某个值的请求，当它用作返回类型时，它是一个当前可能不可用的响应.

• 当 Promise 是一个参数时，它是在某个时刻产生某个值的责任的“消耗”，而当它用作返回类型时，它是产生该值的责任的“生产”在某个时候。

总而言之，能够推理能力，尤其是在异步甚至并发程序中，是非常有价值的。

大多数时候不需要使用 Promise，因为它由 Future-combinators 透明地处理，但在与第三方软件或网络库集成时，它可能非常有用。

有关 Scala 2.12 中有趣的新功能的更多信息，请查看here。

1: 在哪里Future.unit 定义为： val unit: Future[Unit] = Future.successful(())

Answer 2

我说的对吗？ Future 不需要 Promise ，如果 onComplete 签名是 从 Unit 更改为 Future[T]？

你把事情搞混了。让我们澄清一下。

Future[T] 表示将在未来完成的计算。也就是说，您向Future.apply 传递了一个函数，该函数将在您定义的某个ExecutionContext 分配的线程上执行。

另一方面，Promise[T] 是一种创建Future[T]的方法，而无需实际创建Future[T]。一个很好的例子是Future.successful 方法（它将在内部使用Promise.successful）：

def successful[T](result: T): Future[T] = Promise.successful(result).future

这不需要ExecutionContext，也不需要排队（如果有任何其他资源）。它只是一个方便的包装器，可让您“人为”创建Future[T]。

Answer 3

没有。

Future不能涵盖Promise的用例。 Promise 有自己的价值。您不能将Future 替换为Promise。

Future 表示稍后可用的计算。未来执行完成后，您可以使用onComplete 获得结果，您可以使用map、flatMap、recover 和recoverWith 组合期货。

Promise 是一次性写入容器，客户端可以订阅容器。当订阅的客户端获得未来等待，直到将值写入名为 promise 的容器中。

Future 是只读的

您不能将未来用作一次性写入容器。您只能从未来读取。

但Promise 不同。

如果你想给用户一些你现在没有但你认为很快就会有的东西怎么办？

这意味着你向用户承诺你现在没有的东西。

因此，您希望让用户一直等待，直到您拥有要提供给用户的东西。那就是您执行p.future 并生成未来，以便用户可以使用未来等待结果。

一旦你得到了你承诺给用户的结果，你通过在发生不好的事情时将未来设为success 或failure 来给用户（即通过p.complete）。

即使onComplete 返回类型更改为Future[T]。 Future 不能像Promise 那样行事或服务于Promise 的目的。

使用 Future 伴随对象创建未来

也可以使用Future.apply 来创建未来。在这种情况下，一旦 future 内部的计算完成，future created 就会完成。

Future 用于订阅耗时计算的结果，而 Promise 可以是发布和订阅模型。