Question

此代码的目标是采用一系列期货，使用Future.sequence处理它们，生成另一个期货序列并再次使用另一个Future.sequence处理它们。

问题是它不会打印任何东西。这段代码出了什么问题？

object TestFutures extends App {

  def future (i:Int) = Future { i }
  def future2 (i:Int) = Future { i * 20 }

  val futureResult = (1 to 10).map {
     x => future(x)
   }

  var futureInts = Seq[Future[Int]]()

  Future.sequence(futureResult).map{ list => 
     list.foreach( y => futureInts = futureInts :+ future2(y))
   }

  Future.sequence(futureInts).map { list2 => 
     list2.foreach( z => println(z))
   }


  Thread.sleep(5000)
}

Answer 1

它确实有效，你在Thread.sleep和期货结束执行之间只有一个竞争条件。您可以使用Await.result

等待期货完成

import scala.concurrent.{Await, Future}
import scala.concurrent.ExecutionContext.Implicits._
import scala.concurrent.duration._

def future(i: Int) = Future.successful(i)
def future2(i: Int) = Future.successful(i * 20)

val futureResult = (1 to 10).map(x => future(x))

val firstResult =
  Future
   .sequence(futureResult)
   .flatMap(list => Future.sequence(list.map(future2))

val sequence = Await.result(firstResult, 10 seconds)

sequence.foreach(println)

请注意，您不应该同时阻止生产代码中的期货，这仅仅是为了证明未来确实按照您的意愿行事。

两个Future.sequence的序列不起作用

1 个答案: