从List[Future[T]]到Future[List[T]]

在课程<Principles Of Reactive Programming>里Week3的一节 "Promises, promises, promises"中，Erik Meijer举了一个例子，实现一个函数：

def sequence[T](fs: List[Future[T]]): Future[List[T]] = {.....}

这个函数实际在Scala library的Future对象中有标准的实现。

def  sequence[A, M[X] <: TraversableOnce[X]](in: M[Future[A]])(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]], executor: ExecutionContext): Future[M[A]]

 

Simple version of Future.traverse. Transforms a TraversableOnce[Future[A]] into a Future[TraversableOnce[A]]. Useful for reducing many Futures into a single Future.

俺就想试着自己实现一下，于是写出了下面这段有问题的代码……

object ConcurrentTool {
  def collect[T](futures: List[Future[T]]): Future[List[T]] = {
    val p = Promise[List[T]]
    var list = List.empty[T]
    futures.foldLeft(list) {
      (curr, future) => {
        if (p.isCompleted)
          curr
        else {
          future.onComplete {
            case Failure(e) => p.failure(e)
            case Success(e) => list = e :: list
          }
          list
        }
      }
    }
    if (!p.isCompleted)
      p.success(list)
    p.future
  }

def main(args: Array[String]) = {
    def futureOne = {
      Future {
        1
      }
    }
    def futureTwo = {
      Future {
        2
      }
    }

    val collection = collect(List(futureOne, futureTwo))
    val lists = Await.result(collection, 1 seconds)
    println(lists.size)

  }
}

collect方法用于将一个List[Future[T]]变成一个Future[List[T]]。然后我传给它两个future，等返回的Future[List[T]] compelete，然后取结果List的大小，打印出来。

但是结果是0……但是，在我加了断点进行调试时，有时结果是2，为啥呢？ 错误不可怕，这是纠正自己的机会。

再来看一下collect方法的实现吧。我用一个Promise生成最后的future, 用一个空List做为foldLeft的初始值，然后遍历List[Future]里的所有future。对于每个future，给它注册一个回调函数，当它fail的时候，用引起fail的异常去complete跟最后结果相关的那个Promise，如果这个future成功了，就把它的结果附加在list里。在注册完回调之后，我返回保存结果的list。

问题就在这些操作的执行时间上。给future注册回调函数的动作是在main线程中，这个注册不会阻塞main线程的执行，假如被注册的函数的确是在另一个线程中执行的，那么在注册完回调函数之后，我返回的list仍然可能是最初的那个empty list， 所以在foldLeft完成后，foldLeft返回的仍然可能是那个empty list。接下来，我判断p.isCompleted， 如果否，我就用这个list去complete这个Promise，实际上我用一个empty list去complete了它，所以在获取collection的结果后，发现这个是一个空列表。

那么我们想要的结果如何实现呢？关键是，必须得生成这个Future[List]的所有future都compelete时，这个Future[List]才能complete。如何实现这一点呢？

• 我们可以阻塞执行collect方法的线程，显式地等待List[Future]里的所有future完成，再complete跟结果相关的那个Promise。但是这样做，会阻塞调用collect的线程，也违背了我们返回一个Future的目的。
• 我们可以在另一个线程里等待List[Future]里的所有future完成，再complete跟结果相关的那个Promise。在collect方法中，返回Promise对应的future。这样就不会阻塞调用collect的线程。

如何在另一个线程等待呢？可以用Await来阻塞等待，或者注册callback，使得当所有future完成时，callback被调用。

假如有两个Future,可以用下边的代码注册callback。

 def waitBoth[T](futureA: Future[T], futureB: Future[T]): Future[List[T]] = {
    val p = Promise[List[T]]()
    futureA.onComplete{
      case Failure(e) => p.failure(e)
      case Success(t) => futureB.onComplete{
        case Failure(eb) => p.failure(eb)
        case Success(b) => p.success(t :: b :: Nil)
      }
    }
    p.future
  }

这个变形一下，用flatMap和map表示就是

 def waitBoth[T](futureA: Future[T], futureB: Future[T]): Future[List[T]] = {
    val p = Promise[List[T]]()
    futureA.onComplete{
      case Failure(e) => p.failure(e)
      case Success(t) => futureA.flatMap{a: T =>
        futureB map {b =>
          p.success(a :: b :: Nil)
        }
      }
    }
    p.future
  }

实际上Future的map和flatMap在实现时也用了Promise， 上边的代码简化一下就是

  def waitBoth[T](futureA: Future[T], futureB: Future[T]): Future[List[T]] = {
    futureA.flatMap { a: T =>
      futureB map { b =>
        a :: b :: Nil
      }
    }
  }

再把flatMap和map转成for循环表示，就是

  def waitTwo[T](futureA: Future[T], futureB: Future[T]): Future[List[T]] = {
    for {
      a <- futureA
      b <- futureB
    } yield a :: b :: Nil
  }

那么如何组合更多的Future呢？我们来写一个方法把一个Future[T]的结果附加到Future[List[T]]中

  def waitMore[T](futureA: Future[T], futures: Future[List[T]]): Future[List[T]] = {
    for{
      a <- futureA
      b <- futures
    }yield a :: b
  }

然后以此为基础，就可以构造最早提到的sequence函数

  def waitSome[T](futures: List[Future[T]]): Future[List[T]] = {
    val p = Promise[List[T]]()
    p.success(Nil)
    val init: Future[List[T]] = p.future
    futures.foldLeft(init){
      (curr, f) => waitMore(f, curr)
    }
  }

 上边代码关键在于了解到我们需要一个Future作为foldLeft的初始值，它必须是success的，且使其success的值为Nil。这个init实际上也可以用 val init: Future[List[T]] = Future{Nil}来得到。

这种形式距离<Principles Of Reactive Programming>给出的答案已经很接近了。实际上Erik Meijer给出了两个解法，其中跟这个相近的是

  def sequence[T](fs: List[Future[T]]): Future[List[T]] = {
    val successful = Promise[List[T]]
    successful.success(Nil)
    fs.foldRight(successful.future){
      (f, acc) => for{x <-f; xs <- acc} yield x :: xs
    }
  }