java - Scala 异步与 Java ForkJoinTask

Question

前段时间我发现了 Scala Async Project .问题是:这个不能通过普通函数(没有宏扩展)实现的 async block 有什么神奇之处？

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

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;
    }
});

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

Answer 1

您发布的两个片段在幕后的工作方式有一个重要区别:阻止操作。

scala-async 片段大致等同于:

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

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

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

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

总结:scala-async 的目的是使非阻塞、基于回调的异步处理在其语法中像标准的阻塞方法一样自然(例如您在 Java 中使用的那个)。