Scala：合并使用期货超时的排序

Question

下面的顺序合并排序可以非常快速地返回结果：

def mergeSort(xs: List[Int]): List[Int] = {
    def merge(xs: List[Int], ys: List[Int]): List[Int] = (xs, ys) match {
      case (Nil, _) => ys
      case (_, Nil) => xs
      case (x :: xs1, y :: ys1) => if (x <= y) x :: merge(xs1, ys) else y :: merge(xs, ys1)
    }
    val mid = xs.length / 2
    if (mid <= 0) xs
    else {
      val (xs1, ys1) = xs.splitAt(mid)



      merge(mergeSort(xs1), mergeSort(ys1))
    }
  }

  val newList = (1 to 10000).toList.reverse

  mergeSort(newList)

但是，当我尝试使用Future对其进行并行化时，它超时了：-

def mergeSort(xs: List[Int]): List[Int] = {
    def merge(xs: List[Int], ys: List[Int]): List[Int] = (xs, ys) match {
      case (Nil, _) => ys
      case (_, Nil) => xs
      case (x :: xs1, y :: ys1) => if (x <= y) x :: merge(xs1, ys) else y :: merge(xs, ys1)
    }
    val mid = xs.length / 2
    if (mid <= 0) xs
    else {
      val (xs1, ys1) = xs.splitAt(mid)
      val sortedList1 = Future{mergeSort(xs1)}
      val sortedList2 = Future{mergeSort(ys1)}

      merge(Await.result(sortedList1,5 seconds), Await.result(sortedList2,5 seconds))
    }
  }

  val newList = (1 to 10000).toList.reverse

  mergeSort(newList)

我收到超时异常。 我知道这可能是因为此代码产生了log2 10000个线程，这增加了很多延迟，因为执行上下文线程池可能没有那么多线程。

1.）如何在合并排序和代码并行化中利用固有的并行性？

2.）期货在哪些用例中有用，何时应避免使用？

编辑1：基于到目前为止我得到的反馈重构代码：

def mergeSort(xs: List[Int]): Future[List[Int]] = {

    @tailrec
    def merge(xs: List[Int], ys: List[Int], acc: List[Int]): List[Int] = (xs, ys) match {
      case (Nil, _) => acc.reverse ::: ys
      case (_, Nil) => acc.reverse ::: xs
      case (x :: xs1, y :: ys1) => if (x <= y) merge(xs1, ys, x :: acc) else merge(xs, ys1, y :: acc)
    }

    val mid = xs.length / 2
    if (mid <= 0) Future {
      xs
    }
    else {
      val (xs1, ys1) = xs.splitAt(mid)
      val sortedList1 = mergeSort(xs1)
      val sortedList2 = mergeSort(ys1)
      for (s1 <- sortedList1; s2 <- sortedList2) yield merge(s1, s2, List())
    }
  }

Answer 1

通常，在使用期货时，您应该a）尽可能少地等待并且喜欢在Future中工作，并且b）注意所使用的执行上下文。

作为a）的示例，这是您可以如何更改的方法：

def mergeSort(xs: List[Int]): Future[List[Int]] = {
  def merge(xs: List[Int], ys: List[Int]): List[Int] = (xs, ys) match {
    case (Nil, _) => ys
    case (_, Nil) => xs
    case (x :: xs1, y :: ys1) => if (x <= y) x :: merge(xs1, ys) else y :: merge(xs, ys1)
  }
  val mid = xs.length / 2
  if (mid <= 0) Future(xs)
  else {
    val (xs1, ys1) = xs.splitAt(mid)
    val sortedList1 = mergeSort(xs1)
    val sortedList2 = mergeSort(ys1)
    for (s1 <- sortedList1; s2 <- sortedList2) yield merge(s1, s2)
  }
}
val newList = (1 to 10000).toList.reverse

Await.result(mergeSort(newList), 5 seconds)

但是，这里仍然有很多开销。 通常，您只会并行处理大量工作，以避免被开销所控制，在这种情况下，这可能意味着递归达到某个恒定大小以下的列表时，会退回到单线程版本。