期货是否总是最终不返回任何东西？

Question

鉴于我们必须避免...

1) 修改状态 2) 阻塞

...Future 的正确端到端用法是什么？

使用 Futures 的一般做法似乎是通过使用 map、flatMap 等将它们转换为其他 Futures，但永远创建 Futures 并不好。

是否总是会在某处调用 onComplete，方法将 Future 的结果写入应用程序外部的某处（例如 Web 套接字；控制台；消息代理），或者是否有非阻塞方式访问结果？

Scaladocs 中有关 Futures 的所有信息 - http://docs.scala-lang.org/overviews/core/futures.html 似乎最终都会写入控制台。 onComplete 不返回任何内容，因此我们可能不得不最终执行一些“即发即弃”的 IO。

例如致电println

f onComplete {
  case Success(number) => println(number)
  case Failure(err) => println("An error has occured: " + err.getMessage)
}

但是在更复杂的情况下，我们希望对 Future 的结果做更多​​的事情呢？

例如，在 Play 框架中，Action.async 可以返回一个 Future[Result] 并且框架处理其余部分。它最终会不会期望永远不会从未来得到结果？

我们知道用户需要返回一个Result，那么框架如何仅使用一个 Unit 方法来做到这一点？

是否有一种非阻塞的方式来检索未来的值并在应用程序的其他地方使用它，还是调用 Await 是不可避免的？

Answer 1

最佳做法是使用回调，例如 onComplete、onSuccess、onFailure 进行副作用操作，例如日志记录、监控、I/O。

如果您需要继续使用 Future 计算的结果而不是执行副作用操作，则应使用 map 访问计算结果并对其进行组合。

Answer 2

Future 返回一个单位，是的。那是因为它是一个异步触发器。您需要注册回调才能收集结果。

来自您引用的 scaladoc（使用我的 cmets）：

// first assign the future with expected return type to a variable.
val f: Future[List[String]] = Future {
  session.getRecentPosts
}
// immediately register the callbacks
f onFailure {
  case t => println("An error has occurred: " + t.getMessage)
}
f onSuccess {
  case posts => for (post <- posts) println(post) 
}

或者代替 println-ing 你可以对结果做一些事情：

f onSuccess {
  case posts: List[String] => someFunction(posts)
}

Answer 3

试试这个：

import scala.concurrent.duration._
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global

val f: Future[Int] = Future { 43 }

val result: Int = Await.result(f, 0 nanos)

那么这里发生了什么？

您正在定义要在不同的thread 上执行的计算。

所以你Future { 43 } 立即返回。

然后您可以等待它并收集结果（通过Await.result）或在其上定义计算而不等待它完成（通过map 等...）

Answer 4

实际上，您所说的 Future 是用于副作用的。 Future 返回的结果取决于它的类型：

val f = Future[Int] { 42 }

例如，我可以将 Future[Int] 的结果发送到另一个 Future ：

val f2 = f.flatMap(integer => Future{ println(integer) }) // may print 42

如您所知，未来是一个同时发生的过程。所以你可以在未来得到它的结果（也就是使用onComplete等方法）或者通过显式阻塞当前线程直到它得到一个值：

import scala.concurrent.Await
import akka.util.Timeout
import scala.concurrent.duration._

implicit val timeout = Timeout(5 seconds)
val integer = Await.result(Future { 42 }, timeout.duration)

通常当您开始处理异步流程时，您必须考虑可能永远不会发生的反应。使用链式 Futures 就像声明一个可能随时中断的事件链。因此，等待 Future 的值绝对不是一个好习惯，因为你可能永远也得不到它：

val integer = Await.result(Future { throw new RuntimeException() }, timeout.duration) // will throw an uncaught exception

尝试更多地从事件的角度来思考，而不是在程序方面。