Scala 如何防止未来永不完结

假设我有多个要并行运行的任务

每个任务（方法）都有一个内部递归函数，基本上从数据库中获取数据并将其保存在一些数据存储器中

[简化的内部递归函数]

 def simplifiedSomeTask(): Unit = {
    @scala.annotation.tailrec
    def get(
        stream: Stream[SomeEntity],
        result: Seq[SomeEntity],
    ): Stream[SomeEntity] = result match {
      case Nil =>
        stream
      case _ =>
        val query = //query to fetch data from database
        get(
          stream append result.toStream,
          query.run.value, // get fetched data from database
        )
    }

    val buffer = collection.mutable.Map.empty[String, String]

    get(
      Stream.empty,
      query.run.value
    ).foreach { r =>
      buffer.put(r.loginId, r.userId)
    }
  }

当试图经营一个未来时，由于某种原因永远不会结束

[A]

val f1=Future{someTask1（）}
val f2=未来{someTask2（）}
val f3=未来{someTask3（）}
val f=用于{
_我无法重现您的问题，但奇怪行为的原因可能是第一个示例中的语法不完全正确。您应该编写第一个示例，以便理解，如：

val f = for {
  _ <- f1
  _ <- f2
  _ <- f3
} yield ()

问题不在于理解，而在于您的任务。并行运行这些任务可能会出现某种死锁，但我会首先三次检查它们是否以无限循环结束。看看您的示例，如果
query.run.value
从不返回空值，然后递归，则很容易发生这种情况将永远继续。如果
f1
、
f2
和
f3
中的任何一个都无法解析，那么
f
当然也永远无法解析。
结果是，在创建
查询
对象时，一些圆圈引用导致了此问题。
哦，我粘贴不正确。现在我更正了代码。不过，它还是应该d工作，所以问题一定在其他地方。你能分享一下你在未来会做什么吗？我添加了一个简化的内部递归函数，我正在使用这个函数返回
Future[Unit]
，是吗？不是，它只返回Unit。这个函数最后被包装在Future中，所以最终，Future[Unit]确切地说，是什么导致了死锁？每个任务都是相互独立的，从不同的表中获取记录，而不是从相同的表中获取记录。正如我所说的，死锁似乎不太可能，尽管是可能的。在示例代码中，您有一个神奇的
val query=//query从数据库中获取数据。您能证明您的变量始终分配一个迟早会返回空的查询？如果不是，从那里开始，因为如果不知道代码将终止，查找死锁将是浪费时间。
val f = for {
  _ <- Future { someTask1() }
  _ <- Future { someTask2() }
  _ <- Future { someTask3() }
} yield ()

Await.result(f, Duration.Inf)

val f = for {
  _ <- f1
  _ <- f2
  _ <- f3
} yield ()

val f = Future.sequence(
  List(
    Future { someTask1() },
    Future { someTask2() },
    Future { someTask3() }
  )
)