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

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) 

注意，你不应该同步阻塞在期货产品代码，但这仅仅是为了未来做了你希望它是什么做示范。