11

前段时间我发现了Scala Async Project。问题是：这个async块中有什么神奇的东西不能通过普通函数（没有宏扩展）来实现？

让我们看一下介绍中的第一个例子：

import ExecutionContext.Implicits.global
import scala.async.Async.{async, await}

val future = async {
    val f1 = async { ...; true }
    val f2 = async { ...; 42 }
    if (await(f1)) await(f2) else 0
}

在上面的示例中，我没有看到任何不能用纯 Java 编写的内容。这段代码做同样的事情：

import java.util.concurrent.*;
import java.util.function.Supplier;

// First define a helper method for creating async blocks:
public static <T> ForkJoinTask<T> async(Supplier<T> supplier) {
    return new RecursiveTask<T>() {
        @Override
        protected T compute() {
            return supplier.get();
        }
    }.fork();
}

ForkJoinTask<Integer> future = ForkJoinPool.commonPool().submit(() -> {
    ForkJoinTask<Boolean> f1 = async(() -> true);
    ForkJoinTask<Integer> f2 = async(() -> 42);

    if (f1.join()) {
        return f2.join();
    } else {
        return 42;
    }
});

Scalaasync能做什么而 Java 不能？也许在一些更复杂的情况下？我想念什么？

4

1 回答 1

9

您发布的两个片段如何在幕后工作有一个关键区别：阻塞操作。

该scala-async片段大致相当于：

val future = {
  val f1 = Future { ...; true }
  val f2 = Future { ...; 42 }
  f1.flatMap { b =>
    if(b) f2 else Future.successful(0)
  }
}

这是一个基于回调的代码。那里没有会阻塞任何线程的操作。只有未来的包装和回调注册（flatMap在这种情况下发生在幕后）。换句话说，那里的一切都是异步的。

另一方面，joinJava 的 fork-join 池中的方法确实阻塞了线程。

无阻塞操作是显着的性能/可扩展性优势，因为 - 大大简化 - 无阻塞 => 需要更少的线程 => 需要更少的操作系统资源 + 更少的上下文切换。

总结：目的scala-async是使非阻塞、基于回调的异步处理在语法上与标准的阻塞方法一样自然（就像您在 Java 中使用的那样）。

于 2014-03-25T19:45:00.553 回答