Scala 将来和将来的产品语法是异步还是同步？

我已经使用Scala很长一段时间了，现在我遇到了一些麻烦 这是一个非常重要的问题，涉及到如何使用future和yield来理解

for yield语法只是一种语法糖，它简化了flatMap/map链。Futures应该是async的包装器，但flatMap/map的使用似乎起到了更为同步的作用，因为它似乎“等待”要计算的前一个未来调用的结果，以便对其进行操作。所以这突然变得更加混乱，让我回到这个基本问题上来。期货是异步的，但是map/flatmap（用于收益率）的使用是否也是异步的，即使它允许内部的顺序操作用于收益率

---

如果您有任何帮助，我们将不胜感激。

使用a进行理解的用例是指您的未来

让我们用一个例子来解释： FutureB如果它依赖于FutureA值，则需要等待计算FutureA值，然后只有您可以将其传递给FutureB

有两种方法可以解决这个问题：

1.使用地图： 一个基本的组合词是map，它给定一个未来和一个未来值的映射函数，生成一个新的未来，一旦原始的未来成功完成，这个新的未来将用映射值完成。您可以使用与映射集合相同的方式来推理映射未来。 （摘自）

例如：

FutureA.map（FutureB（））

2.用一个句子来理解

val result=for{
map/flatMap

和

for

表达式用于将一个未来转换为另一个未来，并且是异步的

如果是

map/flatMap

：

val future1 = Future {Thread.sleep(10000); 12}
val newFuture = future.map(res => res + 10)

在上面的代码块中，

future1

被转换为

newFuture

，它看起来是同步的，因为

res+10

只会在

future1

完成后计算，它必须等待10秒，等待

future1

完成，然后计算总和并将此计算作为新的future返回。但是，操作是完全异步的，因为它们将在不同的上下文中执行，即

future1

和

newFuture

将在不同的上下文中执行，并且不会相互阻塞，但是

newFuture

希望

future1

成功完成并按顺序返回值

12

执行res+sum，这使得它看起来像是同步过程，但从技术上讲它不是

类似地，如果表达式为

：

val future1 = Future {Thread.sleep(10000); 10}
val future2 = Future {Thread.sleep(15000); 20}
val newFuture = for {
    res1 <- future1
    res2 <- future2
} yield res1+res2

上述未来将至少需要25秒才能完成

另一方面，如果您将一个未来的结果用于另一个未来，那么它将不会并行运行。以下代码等于
future1.map（value=>{Thread.sleep（15000）；20+value}）

val future1=Future{Thread.sleep（10000）；10}
def future2（值：Int）=未来{Thread.sleep（15000）；20+值}
val newFuture=for{
res1您可以这样想：Future上所有有用的方法都会创建新的回调，该回调计划在提供的执行上下文上运行，并在回调完成执行时返回一个新的Future对象，该对象被视为
done
。
如果一个回调依赖于另一个回调，那么它将在第一次完成之前执行，因此没有线程被阻塞

你可以试着在一张纸上把它形象化，这通常有助于你看到它。
map
在
Future
上并不等待，它只是创建一个新的
Future
，当原始
Future
的结果可用时，它会接受它并对其进行更多的处理。
val future1 = Future {Thread.sleep(10000); 10}
val future2 = Future {Thread.sleep(15000); 20}
val newFuture = for {
    res1 <- future1
    res2 <- future2
} yield res1+res2

val newFuture = for {
    res1 <- Future {Thread.sleep(10000); 10}
    res2 <- Future {Thread.sleep(15000); 20}
} yield res1+res2

val future1 = Future {Thread.sleep(10000); 10}
def future2(value: Int) = Future {Thread.sleep(15000); 20 + value}
val newFuture = for {
    res1 <- future1
    res2 <- future2(res1)
} yield res2