Scala - 期货没有开始

Question

我想在一个名为 extraire_phrases 的 Future 方法上启动两个工作人员。我在我的 main 中调用它们，但似乎 Promise 从未实现，并且在我的 main 结束时我没有得到任何东西，就好像工人没有开始一样。有任何想法吗？非常感谢。

object Main {

    val chemin_corpus:String = "src/corpus.txt"
    val chemin_corpus_backup:String = "src/tartarinalpes.txt"
    val chemin_dictionnaire:String = "src/dicorimes.dmp"
    val chemin_dictionnaire_backup:String = "src/dicorimes2.dmp"

    def main(args:Array[String]){

        val quatrain = Promise[List[Phrase]]()

        var grosPoeme = List[Phrase]()

        Future {
          val texte_1 = Phrases.extraire_phrases(chemin_corpus, chemin_dictionnaire)
          val texte_2 = Phrases.extraire_phrases(chemin_corpus_backup, chemin_dictionnaire_backup)

          texte_1.onComplete {
            case Success(list) => {
              val poeme = new DeuxVers(list)
              poeme.ecrire :: grosPoeme
            }
            case Failure(ex) => {
              quatrain.failure(LameExcuse("Error: " + ex.getMessage))
            }
          }

          texte_2.onComplete {
            case Success(lst) => {
              val poeme2 = new DeuxVers(lst)
              poeme2.ecrire :: grosPoeme
            }
            case Failure(ex) => {
              quatrain.failure(LameExcuse("Error: " + ex.getMessage))
            }
          }
        quatrain.success(grosPoeme)
        }

        println(quatrain.future)
        println(grosPoeme)
    }

}

这是执行后我的控制台中的内容：

Future(<not completed>)
List()

即使我在val texte_1 之前删除了Future {，似乎它们都没有正常触发，texte_1 以某种方式启动，有时它工作，有时不工作，并且 texte_2 永远不会启动（永远不会完成）。也没有失败。

// 编辑：Alvaro Carrasco 的答案是正确的。不过谢谢你们俩的帮助

Answer 1

期货是异步执行的，您的代码不会“等待”它们完成。 onComplete 将安排一些代码在未来完成时运行，但不会强制您的程序等待结果。

您需要使用map/flatMap/sequence 对内部期货进行线程化，这样您最终会得到一个单一的期货，然后使用Await.result(...) 等待它。

您实际上并不需要Promise，因为将来会捕获异常。

类似这样的：

object Main {

  val chemin_corpus:String = "src/corpus.txt"
  ...

  def main(args:Array[String]){
    ...

    val f1 = texte_1
      .map {list => 
        val poeme = new DeuxVers(list)
        poeme.ecrire :: grosPoeme
      }

    val f2 = texte_2
      .map {lst => 
        val poeme2 = new DeuxVers(lst)
        poeme2.ecrire :: grosPoeme
      }

    // combine both futures
    val all = for {
      res1 <- f1
      res2 <- f2
    } yield {
      println(...)
    }
    // wait for the combined future
    Await.result(all, 1.hour)
  }
}

Answer 2

for-comprehension on Future 的解决方案。您需要更改 f1 和 f2 才能满足您的需求。 f1 和 f2 将并行执行。 for-comprehension 提供了获得未来结果的优雅方式（它只是 flatMap、filter 等操作组合的语法糖：

import scala.concurrent.{Await, Future}

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global

val f1: Future[Seq[Int]] = Future {
  // Do something here
  Seq(1, 2, 3)
}.recover { case ex =>
    // If Future fails, let's log an exception and return default value
    println(s"Unable to complete f1: $ex")
    Seq.empty[Int]
}

val f2: Future[Seq[Int]] = Future {
  // Do something here
  Seq(4, 5, 6)
}.recover { case ex =>
  // If Future fails, let's log an exception and return default value
  println(s"Unable to complete f2: $ex")
  Seq.empty[Int]
}
// f1 and f2 have started

// we use for-comprehension on Future to get the result
val f = for {
  seq1 <- f1
  seq2 <- f2
} yield seq1 ++ seq2

// Blocking current thread and wait 1 seconds for the result
val r = Await.result(f, 1.seconds)
println(s"Result: $r")