一个线程能阻塞完整的ForkJoinPool吗

Question

我在读https://dzone.com/articles/think-twice-using-java-8

Answer 1

流操作不会阻塞池中的线程，而是会利用它们。根据工作负载的划分，可能所有线程都忙于处理首先开始的流操作，因此它们无法为另一个流操作提取工作负载。文章似乎错误地将“块”一词用于此场景。

值得注意的是，流API和默认实现是为不等待外部事件（阻塞线程）的CPU绑定任务设计的。如果以这种方式使用它，对于总体吞吐量来说，哪个任务让线程保持忙碌并不重要。但是，如果您同时处理不同的请求，并且希望在工作线程分配中有某种公平性，那么这就行不通了。

如果您继续阅读这篇文章，您会看到他们创建了一个示例，假设错误地使用了Stream API，使用了真正的阻塞操作，甚至将第一个示例调用为broked，尽管他们不必要地将其放在引号中。在这种情况下，错误不是使用并行流，而是将其用于阻塞操作。

long t0 = System.nanoTime();
new Thread(() -> {
    Stream.generate(() -> {
        long missing = TimeUnit.SECONDS.toNanos(3) + t0 - System.nanoTime();
        if(missing > 0) {
            System.out.println("blocking "+Thread.currentThread().getName());
            LockSupport.parkNanos(missing);
        }
        return "result";
    }).parallel().limit(100).forEach(result -> {});
    System.out.println("first (blocking) operation finished");
}).start();
for(int i = 0; i< 4; i++) {
    new Thread(() -> {
        LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
        System.out.println(Thread.currentThread().getName()
                          +" starting another parallel Stream");
        Object[] threads =
            Stream.generate(() -> Thread.currentThread().getName())
                .parallel().limit(100).distinct().toArray();
        System.out.println("finished using "+Arrays.toString(threads));
    }).start();
}

blocking ForkJoinPool.commonPool-worker-5
blocking ForkJoinPool.commonPool-worker-13
blocking Thread-0
blocking ForkJoinPool.commonPool-worker-7
blocking ForkJoinPool.commonPool-worker-15
blocking ForkJoinPool.commonPool-worker-11
blocking ForkJoinPool.commonPool-worker-9
blocking ForkJoinPool.commonPool-worker-3
Thread-2 starting another parallel Stream
Thread-4 starting another parallel Stream
Thread-1 starting another parallel Stream
Thread-3 starting another parallel Stream
finished using [Thread-4]
finished using [Thread-2]
finished using [Thread-3]
finished using [Thread-1]
first (blocking) operation finished

^{（详细信息可能不同）}

然而，在创建发起线程（例如，那些接受外部请求的线程）的线程管理和公共池之间可能会发生冲突。但是，如前所述，如果您希望多个独立操作之间的公平性，并行流操作不是正确的工具。