Multithreading Scala未来执行

我有两个未来。我想按顺序执行它们。例如：

val ec: ExecutionContextExecutor = ExecutionContext.Implicits.global
val first=Future.successful(...)
val second=Future.successful(...)

当第一个完成时，则应执行第二个。问题是second应该返回

Future[Object]

而不是

Future[Unit]

so 我无法使用已完成、

和第三个

等函数 我无法使用

wait

或

Thread.sleep（…）

我不能使用for循环，因为执行上下文是这样定义的

first.flatmap（=>second）

将不按顺序执行。

---

我该怎么做呢？

一旦您将

未来

分配给val，该

未来

将被安排并尽快执行。要防止出现这种情况，您有两种选择：

在

def

定义要在哪里使用它的

未来

下面是#1的一个例子：

下面是#2的一个例子：

用于(
i一旦您将
未来
分配给val，该
未来
将被安排并尽快执行。要防止出现这种情况，您有两个选项：

在
def
定义要在哪里使用它的
未来
下面是#1的一个例子：

下面是#2的一个例子：

用于(
我只是把
second
设为
def
而不是
val
？也许你可以对first
Future
进行一些轮询来完成，完成后运行第二个。按照@SaschaKolberg的建议，尝试将
first
和
second
定义为
def
，而不是
val
，然后是
first。flatmap（=>second）
将按顺序完成这两个期货。（没有必要将
first
定义为
def
，但为了对称性，这似乎很好。如果first是
def
，则引用first将重新执行
Future。成功（…）
）当second获取第一个值时，它返回。它不会等到first完成。只需将
second
设置为
def
而不是
val
？也许您可以使用first
Future
的一些轮询来完成，完成后运行第二个。按照@SaschaKolberg的建议，尝试一下将
first
和
second
定义为
def
而不是
val
，然后首先定义
。flatmap（=>second）
将按顺序完成两个期货。（没有必要将
first
定义为
def
，但为了对称性，它似乎很好。如果first是
def
，引用first将重新执行
未来。成功（…）
）它不起作用，因为当second取第一个值时，它返回。它不会等到first完成。
def first: Future[Int] = Future { Thread.sleep(5000); 1 }
def second(i: Int): Future[Unit] = Future { println(i) }
first.flatMap(i => second(i))

for(
  i <- Future { Thread.sleep(5000); 1 };
  _ <- Future { println(i) }
) yield ()