Scala 异步编程：Future 与 Await

Scala 中的异步编程主要通过 Future 和 Await 实现。Future 表示一个可能尚未完成的计算结果，而 Await 允许你在必要时阻塞等待这个结果。掌握这两者的正确用法，能让你写出高效、响应迅速的程序。

准备工作：引入必要的依赖和执行上下文

1. 确保项目已添加 Scala 标准库依赖。通常使用 sbt 构建工具时，无需额外配置，因为 scala.concurrent 包含在标准库中。
2. 导入 Future 和 ExecutionContext：

   import scala.concurrent.Future
   import scala.concurrent.ExecutionContext.Implicits.global

   这里的 ExecutionContext.Implicits.global 提供了一个默认的线程池，用于执行异步任务。你可以替换为自定义的线程池以满足特定性能需求。

3. （可选）导入 Await 和 Duration，以便后续使用阻塞等待：

   import scala.concurrent.Await
   import scala.concurrent.duration._

创建并使用 Future

1. 用花括号包裹一段代码创建 Future：

   val futureResult: Future[Int] = Future {
     // 模拟耗时操作，例如网络请求或文件读取
     Thread.sleep(1000)
     42
   }

   此操作会立即返回一个 Future[Int]，实际计算在后台线程中进行。

2. 通过回调处理 Future 的结果，避免阻塞主线程：
   • 使用 onComplete 处理成功或失败：

     futureResult.onComplete {
       case scala.util.Success(value) => println(s"结果是: $value")
            case scala.util.Failure(exception) => println(s"出错了: ${exception.getMessage}")
     }

     注意：onComplete 的回调在任意线程执行，不适合更新 UI 或共享状态。

   • 使用 map 转换成功结果：

     val doubled: Future[Int] = futureResult.map(_ * 2)

     如果 futureResult 成功完成，doubled 将包含其值乘以 2；如果失败，则直接传递异常。

   • 使用 flatMap 组合多个异步操作：

     val chained: Future[String] = futureResult.flatMap { num =>
       Future(s"原始值是 $num，加倍后是 ${num * 2}")
     }

     这允许你将多个 Future 串行执行，形成链式调用。

3. 使用 for 表达式简化多个 Future 的组合：

   val futureA = Future { 10 }
   val futureB = Future { 20 }
   val sum: Future[Int] = for {
     a <- futureA
     b <- futureB
   } yield a + b

   当 futureA 和 futureB 都成功完成时，sum 将包含它们的和。

使用 Await 安全地获取结果

1. 仅在绝对必要时使用 Await.result，例如在主程序退出前等待关键任务完成：

   val result: Int = Await.result(futureResult, 5.seconds)
   println(s"同步获取的结果: $result")
      ```
      第二个参数是最大等待时间，类型为 `Duration`。如果超时，会抛出 `TimeoutException`。
   2. **永远不要在异步回调内部或 Web 请求处理线程中使用 Await**，这会导致线程阻塞，严重降低系统吞吐量。
   3. **捕获 Await 可能抛出的异常**：
      ```scala
      try {
        val value = Await.result(futureResult, 2.seconds)
        println(s"成功: $value")
   } catch {
     case _: java.util.concurrent.TimeoutException =>
       println("等待超时")
     case ex: Exception =>
       println(s"Await 过程中出错: ${ex.getMessage}")
   }

处理 Future 的失败情况

1. 使用 recover 提供默认值应对失败：

   val safeFuture: Future[Int] = futureResult.recover {
     case _: Exception => 0
   }

   如果 futureResult 失败，safeFuture 将成功完成并返回 0。

2. 使用 recoverWith 替换为另一个 Future：

   val fallbackFuture: Future[Int] = futureResult.recoverWith {
     case _: Exception => Future.successful(999)
   }

   这在实现重试逻辑时非常有用。

3. 组合多个 Future 时注意失败传播：任何一个 Future 失败，整个组合（如 for 表达式）就会失败。

最佳实践与常见陷阱

1. 避免在 Future 内部使用阻塞操作（如 Await.result），这会耗尽线程池资源。
2. 合理设置超时时间：过长的超时可能导致资源长时间占用，过短则可能频繁触发超时异常。
3. 优先使用非阻塞回调（如 map/flatMap）而非 Await，保持程序的异步特性。
4. 在测试中可以安全使用 Await，因为测试环境通常允许短暂阻塞。

以下表格总结了 Future 常用方法的行为差异：

5. 不要重复使用同一个 Future 实例多次调用 Await：Future 是一次性的，重复 Await 同一个实例不会重新计算，但也不会造成问题；不过应确保只在必要位置等待。
6. 在生产环境中替换全局 ExecutionContext：global 线程池适合一般用途，但对于 IO 密集型任务，应使用自定义的、具有更多线程的线程池。