将List[Future[A]]转为Future[(List[A], List[Throwable])]的最优实现探讨

当前实现的问题 #

你的这段代码逻辑上能正常运行，但存在两个明显的问题：

• 串行执行浪费性能：foldLeft会逐个处理列表中的Future，必须等前一个Future完成才会处理下一个。而Future本可以并行执行，这种写法把并行逻辑改成了串行，列表越大，性能损耗越明显。
• 可读性待提升：用元组(oks, errs)传递中间结果，后续处理用_1、_2取值，逻辑复杂时容易混淆，不如自定义类清晰直观。

另外，代码仅捕获NonFatal异常，若遇到致命异常（如OutOfMemoryError），整个Future会直接失败，而非将异常加入错误列表——这一点需结合业务场景判断：如果仅需处理非致命异常，当前写法没问题；若要兜底所有异常，可将NonFatal(e)改为case e: Throwable。

更优的实现方案 #

核心思路是让所有Future并行执行，再统一收集结果，大幅提升性能。

方案一：用Future.sequence+Either处理 #

先将每个Future转换为「成功返回Right[A]，失败返回Left[Throwable]」的Future，再通过Future.sequence并行收集所有结果，最后拆分成功与失败列表：

import scala.concurrent.{ExecutionContext, Future}

def foo[A](futures: List[Future[A]])(implicit ec: ExecutionContext): Future[(List[A], List[Throwable])] = {
  // 转换每个Future为Future[Either[Throwable, A]]
  val eitherFutures = futures.map { f =>
    f.map(Right(_)).recover { case e => Left(e) }
  }
  // 并行收集结果并拆分
  Future.sequence(eitherFutures).map { eithers =>
    val (errors, successes) = eithers.partitionMap(identity)
    (successes, errors)
  }
}

该方案优势：

• 所有Future并行执行，性能远优于串行实现
• 逻辑清晰，每一步职责明确，降低出错概率
• 可灵活调整异常捕获范围，适配不同业务需求

如果偏好使用Try代替Either，逻辑类似：

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

def foo[A](futures: List[Future[A]])(implicit ec: ExecutionContext): Future[(List[A], List[Throwable])] = {
  val triedFutures = futures.map(_.map(Success(_)).recover { case e => Failure(e) })
  Future.sequence(triedFutures).map { tries =>
    val (successes, failures) = tries.partition(_.isSuccess)
    (successes.map(_.get), failures.map(_.failed.get))
  }
}

方案二：优化原串行实现（若必须串行） #

如果业务场景确实需要串行处理Future（如依赖前一个执行结果），可将元组替换为自定义case class提升可读性：

import scala.concurrent.{ExecutionContext, Future}
import scala.util.control.NonFatal

// 自定义结果类，替代元组，可读性更强
case class ProcessResult[A](successes: List[A], errors: List[Throwable])

def foo[A](futures: List[Future[A]])(implicit ec: ExecutionContext): Future[(List[A], List[Throwable])] =
  futures.foldLeft(Future.successful(ProcessResult(Nil, Nil))) { (acc, currentFuture) =>
    acc.flatMap { result =>
      currentFuture.map(ok => result.copy(successes = ok :: result.successes))
        .recover { case NonFatal(e) => result.copy(errors = e :: result.errors) }
    }
  }.map(res => (res.successes.reverse, res.errors.reverse))

补充讨论 #

解构元组 vs 命名字段 #

用case (oks, errs)解构元组虽能实现功能，但自定义case class（如上述ProcessResult）可为字段赋予明确名称，后续维护代码时无需猜测_1、_2的含义，可读性与可维护性大幅提升。

foldRight与foldLeft+reverse的性能对比 #

对于Scala的List，foldRight是从右往左遍历，foldLeft是从左往右遍历后加reverse。两者处理的元素数量完全一致，性能无显著差异。但foldLeft经过尾递归优化，不会因列表过大导致栈溢出；而foldRight不具备尾递归特性，大列表场景下可能出现栈溢出问题。因此你原代码使用foldLeft+reverse的方式更安全，性能与foldRight持平，还能避免栈溢出风险。

内容的提问来源于stack exchange，提问作者andrey.ladniy