为什么静态初始化程序中带有 lambda 的并行流会导致死锁？

Question

我遇到了一个奇怪的情况，在静态初始化程序中使用带有 lambda 的并行流似乎永远不会占用 CPU。代码如下：

class Deadlock {
    static {
        IntStream.range(0, 10000).parallel().map(i -> i).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

这似乎是此行为的最小重现测试用例。如果我：

• 将块放在 main 方法中，而不是静态初始化器中，
• 移除并行化，或
• 删除 lambda，

代码立即完成。谁能解释这种行为？这是一个错误还是有意为之？

我使用的是 OpenJDK 版本 1.8.0_66-internal。

Answer 1

我发现了一个非常相似的案例 (JDK-8143380) 的错误报告，该案例已被 Stuart Marks 关闭为“不是问题”：

这是一个类初始化死锁。测试程序的主线程执行类静态初始化器，它为类设置初始化进行中标志；此标志保持设置，直到静态初始化程序完成。静态初始化程序执行一个并行流，这会导致 lambda 表达式在其他线程中进行计算。这些线程阻塞等待类完成初始化。但是，主线程被阻塞等待并行任务完成，导致死锁。

应更改测试程序以将并行流逻辑移到类静态初始化程序之外。关闭不是问题。

---

我找到了另一个错误报告 (JDK-8136753)，同样被 Stuart Marks 关闭为“不是问题”：

这是一个死锁，因为 Fruit 枚举的静态初始化程序与类初始化交互不良。

有关类初始化的详细信息，请参阅 Java 语言规范第 12.4.2 节。

http://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.4.2

简而言之，发生的事情如下。

1. 主线程引用 Fruit 类并启动初始化过程。这会设置初始化进行中标志并在主线程上运行静态初始化程序。
2. 静态初始化程序在另一个线程中运行一些代码并等待它完成。此示例使用并行流，但这与流本身无关。以任何方式在另一个线程中执行代码，并等待该代码完成，将具有相同的效果。
3. 另一个线程中的代码引用了 Fruit 类，该类检查初始化进行中标志。这会导致另一个线程阻塞，直到标志被清除。 （请参阅 JLS 12.4.2 的第 2 步。）
4. 主线程被阻塞，等待其他线程终止，因此静态初始化程序永远不会完成。由于在静态初始化程序完成之前，初始化进行中标志不会被清除，因此线程处于死锁状态。

为避免此问题，请确保类的静态初始化快速完成，而不会导致其他线程执行需要此类已完成初始化的代码。

关闭不是问题。

---

请注意，FindBugs has an open issue for adding a warning 适用于这种情况。

Answer 2

对于那些想知道引用 Deadlock 类本身的其他线程在哪里的人，Java lambda 的行为就像您写的那样：

public class Deadlock {
    public static int lambda1(int i) {
        return i;
    }
    static {
        IntStream.range(0, 10000).parallel().map(new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return lambda1(operand);
            }
        }).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

使用常规匿名类没有死锁：

public class Deadlock {
    static {
        IntStream.range(0, 10000).parallel().map(new IntUnaryOperator() {
            @Override
            public int applyAsInt(int operand) {
                return operand;
            }
        }).count();
        System.out.println("done");
    }
    public static void main(final String[] args) {}
}

Answer 3

Andrei Pangin 于 2015 年 4 月 7 日对这个问题进行了很好的解释。here 可用，但它是用俄语编写的（无论如何我建议查看代码示例 - 它们是国际化的）。一般问题是类初始化期间的锁。

以下是文章中的一些引述：

---

根据JLS，每个类都有一个唯一的初始化锁，该锁在初始化期间被捕获。当其他线程在初始化期间试图访问这个类时，它将被锁在锁上，直到初始化完成。当类同时初始化时，可能会出现死锁。

我写了一个计算整数和的简单程序，它应该打印什么？

public class StreamSum {
    static final int SUM = IntStream.range(0, 100).parallel().reduce((n, m) -> n + m).getAsInt();

    public static void main(String[] args) {
        System.out.println(SUM);
    }
} 

现在删除 parallel() 或将 lambda 替换为 Integer::sum 调用 - 会有什么变化？

这里我们又看到了死锁[在文章前面的类初始化器中有一些死锁的例子]。由于parallel() 流操作在单独的线程池中运行。这些线程尝试执行 lambda body，它以字节码形式作为 private static 类中的 private static 方法写入 StreamSum 。但是这个方法在类静态初始化器完成之前不能执行，它等待流完成的结果。

更令人兴奋的是：此代码在不同环境中的工作方式不同。它可以在单 CPU 机器上正常工作，并且很可能会在多 CPU 机器上挂起。这种差异来自 Fork-Join 池的实现。你可以自己验证改参数-Djava.util.concurrent.ForkJoinPool.common.parallelism=N