在上一篇教程中，我们探讨了Scala中的并发工具，包括锁和信号量等。在本篇中，我们将深入了解Future和Promise，两者是Scala中实现并发编程的重要基础。

Future

Future代表一个可能在未来某个时刻完成的计算。它是一个异步计算的容器，可以在将来获取结果的值或异常。使用Future，你可以轻松地编写非阻塞代码。

创建Future

你可以使用Future伴生对象中的apply方法来创建一个新的Future。创建Future时，你通常会传递一个计算块。

import scala.concurrent.{Future, ExecutionContext}
import scala.util.{Success, Failure}

implicit val ec: ExecutionContext = ExecutionContext.global

val futureResult: Future[Int] = Future {
  // 模拟长时间计算
  Thread.sleep(1000)
  42
}

在上面的例子中，我们通过Future创建了一个计算，它将在1秒后返回42。

处理Future

我们可以使用onComplete、onSuccess和onFailure等方法来处理Future的结果。以下是如何处理计算结果的示例：

futureResult.onComplete {
  case Success(value) => println(s"计算成功：$value")
  case Failure(exception) => println(s"计算失败：$exception")
}

这里，onComplete方法允许你在计算完成后处理它的结果。无论是成功的结果还是失败的异常，都可以在这里得到处理。

链式操作Future

你可以使用map和flatMap对Future进行链式操作，以便在计算完成时继续进行其他计算。例如：

val doubledFuture: Future[Int] = futureResult.map(value => value * 2)

doubledFuture.onComplete {
  case Success(value) => println(s"加倍结果：$value")
  case Failure(exception) => println(s"失败：$exception")
}

在这个例子中，当futureResult完成时，doubledFuture会接收到结果并将其加倍。

Promise

Promise是一个可以在将来设置立约的对象。通过Promise，你可以控制Future的完成状态和结果。创建Promise后，你可以用它来完成一个Future。

创建Promise

首先，我们需要创建一个Promise，然后通过其success或failure方法来设置Future的结果：

import scala.concurrent.Promise

val promise = Promise[Int]()
val futureFromPromise: Future[Int] = promise.future

// 模拟异步计算
Future {
  // 计算完成后成功设置Promise
  Thread.sleep(500)
  promise.success(100)
}

// 处理Promise中的Future
futureFromPromise.onComplete {
  case Success(value) => println(s"Promise计算成功：$value")
  case Failure(exception) => println(s"Promise计算失败：$exception")
}

在这个例子中，我们创建了一个Promise，并在另一个Future中进行了计算，最后通过调用promise.success(100)来完成它。

使用Promise控制Future的执行

通过Promise，你可以在适当的时候设置Future的结果，这使得它非常适用于事件驱动的编程模型。

总结

在本章中，我们主要讨论了Scala中的Future和Promise，为并发编程提供了强大的支持。Future使我们能够编写非阻塞的异步代码，而Promise则提供了一种控制和管理Future结果的机制。

接下来，我们将探讨Scala与Java的互操作性，包括如何在Scala代码中调用Java代码，反之亦然。这将有助于我们更好地理解这两种语言之间的紧密集成。

Jupyter AI

27 并发编程之Future与Promise