为什么在使用forEachOrdered的静态初始化程序块中使用lambda的并行流处理会产生死锁，而在使用forEach的情况下不会？

Question

在使用Java并行流时，当一些并行操作在静态初始化程序块中完成时，我遇到了死锁。

当使用顺序流时，一切工作正常：

import java.util.Arrays;
public class Example1 {
    static {
        // displays the numbers from 1 to 10 ordered => no thread issue
        Arrays.asList(1,2,3,4,5,6,7,8,9,10)
             .forEach(s->System.out.println(s));
    }
    public static final void main(String[] args) {}
}

当并行处理流时，每一项工作(数字显示没有顺序)：

import java.util.Arrays;
public class Example2 {
    static {
        // displays the numbers from 1 to 10 unordered => no thread issue
        Arrays.asList(1,2,3,4,5,6,7,8,9,10).parallelStream()
             .forEach(s->System.out.println(s));
    }
    public static final void main(String[] args) {}
}

但是，当使用forEachOrdered()处理流时，会发生死锁(我认为这与主线程和ForkJoinPool管理之间的交互有关)：

import java.util.Arrays;
public class Example3 {
    static {
        // hangs forever (deadlock between the main thread which loads the class and the underlying ForkJoinPool which join several tasks)
        Arrays.asList(1,2,3,4,5,6,7,8,9,10).parallelStream()
                .forEachOrdered(s->System.out.println(s));
    }
    public static final void main(String[] args) {}
}

但是，当在单独的线程中派生流处理时，一切都进行得很顺利：

import java.util.Arrays;
public class Example4 {
    static {
        // displays the numbers from 1 to 10 ordered => no thread issue
        new Thread(()->
            Arrays.asList(1,2,3,4,5,6,7,8,9,10).parallelStream()
                 .forEachOrdered(s->System.out.println(s))
        ).start();
    }
    public static final void main(String[] args) {}
}

从我从线程转储中看到的情况来看，主线程正在等待.forEachOrdered()中使用的ForkJoinPool来完成他的工作，但是池中的第一个辅助线程被阻塞，等待某些东西(很可能是被main线程阻塞的)。

我真的很想了解为什么在某些情况下会发生死锁，而在其他情况下不会。这显然不仅仅是由于静态初始值设定器块、并行流和λ的使用，因为Example2、Example3和Example4使用了这三个概念，但只有Example3会导致死锁。

虽然这个问题看起来像是Why does parallel stream with lambda in static initializer cause a deadlock?的副本，但它不是。我的问题超出了链接的问题，因为它提供了Example2，我们为它提供了静态初始化块，并行流和λ，但没有死锁。这就是为什么问题标题包含“可能导致死锁，但不一定”的原因。

Answer 1

这种死锁行为有两个根本原因：

1. main线程正在等待另一个线程(假设是OtherThread)完成其工作(在Example3中，OtherThread是forEachOrdered()操作使用的Lambda的线程之一)
2. <代码>D9使用一个Lambda表达式，该表达式将由<代码>D10线程定义，但在以后(回想一下:Lambda是在运行时创建的，而不是在编译时创建的)。在.forEachOrdered().

中，这是Example3中的Lambda

让我们回顾一下这些示例，并解释它们为什么会产生死锁。

Example1

只有一个线程(main)执行以下操作：

1. 处理静态初始值设定项块
2. 在处理第一个流元素

时，在运行时对每个流元素表达式执行foreach

因为只有一个线程，所以不会发生死锁。

Example2

为了更好地理解处理过程，我们可以将其重写为：

import java.util.Arrays;
public class Example2Instrumented {
    static {
        // displays the numbers from 1 to 10 unordered => no thread issue
        System.out.println(Thread.currentThread().getName()+" : "+"static initializer");
        Arrays.asList(1,2,3,4,5,6,7,8,9,10)
             .parallelStream()
             .forEach(s->System.out.println(Thread.currentThread().getName()+" : "+s));
    }
    public static final void main(String[] args) {}
}

这将产生以下结果：

main : static initializer
main : 7
main : 6
ForkJoinPool.commonPool-worker-2 : 9
ForkJoinPool.commonPool-worker-4 : 5
ForkJoinPool.commonPool-worker-9 : 3
ForkJoinPool.commonPool-worker-11 : 2
ForkJoinPool.commonPool-worker-2 : 10
ForkJoinPool.commonPool-worker-4 : 4
ForkJoinPool.commonPool-worker-9 : 1
ForkJoinPool.commonPool-worker-13 : 8

Lambda线程处理静态初始化器，然后在处理第一个元素时启动forEach并在运行时构建main。其他流元素由来自ForkJoinPool的工作线程处理。没有死锁，因为lambda线程处理了第一个元素并构建了main。

Example3

我们可以在没有Lambda的情况下重写Example3来打破死锁：

import java.util.Arrays;
import java.util.function.Consumer;
public class Example3NoDeadlock {
    static {
        // displays the numbers from 1 to 10 ordered => no thread issue anymore
        Arrays.asList(1,2,3,4,5,6,7,8,9,10).parallelStream()
                .forEachOrdered(
                    new Consumer<Integer>() {
                        @Override
                        public void accept(Integer t) {
                            System.out.println(t);          
                    }});
    }
    public static final void main(String[] args) {}
}

由于Consumer类是在编译时构造的(与在运行时构建的lambda相反)，这打破了死锁循环。这证明至少lambda参与了死锁。

为了更好地理解，我们可以按如下方式插入代码：

import java.util.Arrays;
import java.util.function.Consumer;
public class Example3Instrumented {
    static {
        System.out.println("static initializer");
        // hangs forever (deadlock between the main thread which loads the class and the underlying ForkJoinPool which join several tasks)
        Arrays.asList(1,2,3,4,5,6,7,8,9,10).parallelStream()
            .peek(new Consumer<Integer>() {
                @Override
                public void accept(Integer t) {
                        System.out.println(Thread.currentThread().getName()+" "+t);
            }})
                .forEachOrdered(s->System.out.println(s));
    }
    public static final void main(String[] args) {}
}

这将生成以下输出：

main : static initializer
ForkJoinPool.commonPool-worker-6 1
ForkJoinPool.commonPool-worker-9 3
main 7
ForkJoinPool.commonPool-worker-4 2
ForkJoinPool.commonPool-worker-13 6
ForkJoinPool.commonPool-worker-11 8
ForkJoinPool.commonPool-worker-15 5
ForkJoinPool.commonPool-worker-2 9
ForkJoinPool.commonPool-worker-4 10
ForkJoinPool.commonPool-worker-9 4

Task线程处理静态初始值设定项，然后通过为流中的每个元素创建一个main开始处理forEachOrdered (为了保持顺序，使用了一种复杂的基于树的算法，请参阅ForEachOps.ForEachOrderedTask：任务已创建，从代码看，每个任务都在等待另一个任务完成运行)。所有任务都提交给ForkJoinPool。我认为死锁的发生是因为第一个任务是由来自ForkJoinPool的工作线程处理的，而这个线程等待main线程来构建lambda。并且main线程已经开始处理其任务，并且正在等待另一个工作线程完成其任务以运行。因此出现了僵局。

Example4

在Example4中，我们产生一个异步运行的新线程(即我们不等待结果)。这就是为什么Lambda线程没有被锁定，并且现在有时间在运行时构建main。

结论

带给我们的教训是:如果你混合了静态初始化器、线程和lambda，你应该真正理解这些概念是如何实现的，否则你可能会死锁。