示例1

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()处理Stream时，会发生死锁（我想这与主线程和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) {}
}

但是当在单独的线程中生成Stream处理时，一切进行得很好：

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线程阻止了。）

我非常感谢理解为什么在某些情况下而不是在其他情况下会发生死锁。显然，这不仅是由于静态初始化程序块，并行流和lambda的使用，因为Example2，Example3和Example4使用了这三个概念，而且只有Example3会导致僵局。

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

Answer 1

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

main线程正在等待另一个线程（例如OtherThread）完成工作（在Example3中，OtherThread是ForkJoinPool的线程之一由forEachOrdered()操作使用）
OtherThread使用Lambda表达式，该表达式将由main线程定义，但稍后（请注意：Lambda在运行时创建，而不是在编译时创建）。在Example3中，此Lambda是.forEachOrdered()中的那个Lambda。

让我们回顾这些示例并解释为什么它们产生或不产生死锁。

示例1

只有一个线程（main）执行以下操作：

处理静态初始化程序块
在每个元素上进行foreach
在处理第一个流元素时在运行时创建lambda表达式

由于只有一个线程，因此不会发生死锁。

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

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

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

main线程处理静态初始值设定项，然后通过为流中的每个元素创建一个Task来开始处理forEachOrdered（要维持顺序，将使用基于树的复杂算法，请参见{{1} }：创建了任务，并从代码中看起来每个任务都在等待另一个任务完成运行。所有任务均已提交到ForEachOps.ForEachOrderedTask。我认为发生死锁是因为第一个任务是由来自ForkJoinPool的工作线程处理的，并且此线程等待ForkJoinPool线程来构建lambda。 main线程已经开始处理其任务，并且正在等待另一个辅助线程完成其任务的运行。因此陷入僵局。

Example4

在Example4中，我们产生了一个异步运行的新线程（即，我们不等待结果）。这就是main线程未锁定且现在有时间在运行时构建Lambda的原因。

结论

收获的教训是：如果混合使用静态初始化器，线程和lambda，则应该真正了解这些概念的实现方式，否则可能会出现死锁。

为什么在静态初始化程序块中使用forEachOrdered在lambda上进行并行流处理会产生死锁，而对于forEach却不会产生死锁？

1 个答案:

示例1

Example2

Example3

Example4

结论