如何使涉及期货尾递归的函数？

Posted 2023-03-23

【中文标题】如何使涉及期货尾递归的函数？

【英文标题】：How do I make a function involving futures tail recursive?

【发布时间】：2013-06-03 03:43:02

【问题描述】：

在我的 Scala 应用程序中，我有一个函数调用一个返回 Future[T] 类型结果的函数。我需要在我的递归函数调用中传递映射结果。我希望这是尾递归，但地图（或 flatMap）正在破坏这样做的能力。我收到一个错误“递归调用不在尾部位置。”

以下是此场景的一个简单示例。如何修改它以使调用是尾递归的（不破坏带有 Await.result() 的 Futures 的好处）？

import scala.annotation.tailrec
import scala.concurrent.Await, Future
import scala.concurrent.duration._

implicit val ec = scala.concurrent.ExecutionContext.global

object FactorialCalc 
  def factorial(n: Int): Future[Int] = 

    @tailrec
    def factorialAcc(acc: Int, n: Int): Future[Int] = 
      if (n <= 1) 
        Future.successful(acc)

       else 
        val fNum = getFutureNumber(n)
        fNum.flatMap(num => factorialAcc(num * acc, num - 1))
      
    

    factorialAcc(1, n)
  

  protected def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)


Await.result(FactorialCalc.factorial(4), 5.seconds)

【参考方案1】：

我可能弄错了，但在这种情况下，您的函数不需要是尾递归的。

尾递归有助于我们在使用递归函数时不消耗堆栈。但是，在您的情况下，我们实际上并没有像典型的递归函数那样消耗堆栈。

这是因为“递归”调用将在执行上下文的某个线程上异步发生。因此，这个递归调用很可能甚至不会与第一次调用驻留在同一堆栈中。

factorialAcc 方法将创建最终将异步触发“递归”调用的未来对象。之后，它立即从堆栈中弹出。

所以这实际上不是堆栈递归，堆栈不会与 n 成比例地增长，它大致保持在一个恒定的大小。

您可以通过在 factorialAcc 方法中的某个点抛出异常并检查堆栈跟踪来轻松检查这一点。

我重写了你的程序以获得更易读的堆栈跟踪：

object Main extends App 
  import scala.concurrent.Await, Future
  import scala.concurrent.duration._

  implicit val ec = scala.concurrent.ExecutionContext.global

  def factorialAcc(acc: Int, n: Int): Future[Int] = 

    if (n == 97)
      throw new Exception("n is 97")

    if (n <= 1) 
      Future.successful(acc)

     else 
      val fNum = getFutureNumber(n)
      fNum.flatMap(num => factorialAcc(num * acc, num - 1))
    
  


  def factorial(n: Int): Future[Int] = 
      factorialAcc(1, n)
  

  protected def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)

  val r = Await.result(factorial(100), 5.seconds)
  println(r)

输出是：

Exception in thread "main" java.lang.Exception: n is 97
at test.Main$.factorialAcc(Main.scala:16)
at test.Main$$anonfun$factorialAcc$1.apply(Main.scala:23)
at test.Main$$anonfun$factorialAcc$1.apply(Main.scala:23)
at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:278)
at scala.concurrent.Future$$anonfun$flatMap$1.apply(Future.scala:274)
at scala.concurrent.impl.CallbackRunnable.run(Promise.scala:29)
at scala.concurrent.impl.ExecutionContextImpl$$anon$3.exec(ExecutionContextImpl.scala:107)
at scala.concurrent.forkjoin.ForkJoinTask.doExec(ForkJoinTask.java:262)
at scala.concurrent.forkjoin.ForkJoinPool$WorkQueue.runTask(ForkJoinPool.java:975)
at scala.concurrent.forkjoin.ForkJoinPool.runWorker(ForkJoinPool.java:1478)
at scala.concurrent.forkjoin.ForkJoinWorkerThread.run(ForkJoinWorkerThread.java:104)

所以你可以看到堆栈实际上很短。如果这是堆栈递归，您应该已经看到了大约 97 次对 factorialAcc 方法的调用。相反，您只会看到一个。

【讨论】：

我认为这个答案适合我的需要，但是仍然存在轻微的内存泄漏，因为 scala.concurrent Futures 没有被合并。但是，twitter Futures 以某种方式做的巫术。话虽如此，您必须在崩溃之前深入。比现实更深，所以我对此很满意。

我正在使用 Play 的 WS 客户端库调查类似的 here。您对这个内存泄漏问题有更深入的了解吗？

堆栈如何保持大致恒定的大小？作为堆栈的整体大小是否会不仅仅分布在不同的线程中？

【参考方案2】：

改用 foldLeft 怎么样？

def factorial(n: Int): Future[Int] = future 
  (1 to n).foldLeft(1)  _ * _ 

【讨论】：

这没有抓住问题的重点。虽然该示例确实适用于该问题的尾递归解决方案。真正的问题是函数本身需要调用另一个返回 Future 的函数。所以这在这里行不通。

【参考方案3】：

这是一个 foldLeft 解决方案，它调用另一个返回未来的函数。

def factorial(n: Int): Future[Int] =
  (1 to n).foldLeft(Future.successful(1)) 
    (f, n) => f.flatMap(a => getFutureNumber(n).map(b => a * b))
  

def getFutureNumber(n: Int) : Future[Int] = Future.successful(n)

【参考方案4】：

使 factorialAcc 返回一个 Int 并仅将其包装在 factorial 函数中。

def factorial(n: Int): Future[Int] = 

    @tailrec
    def factorialAcc(acc: Int, n: Int): Int = 
      if (n <= 1) 
        acc
       else 
        factorialAcc(n*acc,n-1)
      
    

    future 
      factorialAcc(1, n)
    

应该可以工作。

【讨论】：

函数本身需要调用另一个返回 Future 的函数。所以这在这里行不通。不过马吕斯的回答是正确的。