ForkJoinPool并行度= 1死锁

我正在使用jsr166y ForkJoinPool在线程之间分配计算任务。但我显然一定会做错事。ForkJoinPool并行度= 1死锁

如果我创建并行度> 1（缺省值为Runtime.availableProcessors（）;我已使用2-8个线程运行）的ForkJoinPool，我的任务看起来完美无缺。但是，如果我创建并行度= 1的ForkJoinPool，则会在无法预测的迭代次数后看到死锁。

是 - 设置并行度= 1是一种奇怪的做法。在这种情况下，随着线程数量的增加，我正在分析并行算法，并且我想将并行版本（与单个线程一起运行）与基准串行实现进行比较，以便准确确定并行实现的开销。

下面是一个简单的例子，说明我看到的问题。 '任务'是对固定数组的虚拟迭代，递归地分为16个子任务。

如果在THREADS = 2（或更多）的情况下运行，它可以可靠地运行到完成，但是如果在THREADS = 1的情况下运行，它总是会死锁。在不可预知的迭代次数后，主循环挂在ForkJoinPool.invoke（）中，等待task.join（），并且工作线程退出。

我与JDK 1.6.0_21和1.6.0_22运行在Linux下，使用版本jsr166y的下载前几天Doug Lea的网站（http://gee.cs.oswego.edu/dl/concurrency-interest/index.html）

对我失去了我的任何建议？提前谢谢了。

package concurrent; 

import jsr166y.ForkJoinPool; 
import jsr166y.RecursiveAction; 

public class TestFjDeadlock { 

    private final static int[] intArray = new int[256 * 1024]; 
    private final static float[] floatArray = new float[256 * 1024]; 

    private final static int THREADS = 1; 
    private final static int TASKS = 16; 
    private final static int ITERATIONS = 10000; 

    public static void main(String[] args) { 

     // Initialize the array 
     for (int i = 0; i < intArray.length; i++) { 
      intArray[i] = i; 
     } 

     ForkJoinPool pool = new ForkJoinPool(THREADS); 

     // Run through ITERATIONS loops, subdividing the iteration into TASKS F-J subtasks 
     for (int i = 0; i < ITERATIONS; i++) { 
      pool.invoke(new RecursiveIterate(0, intArray.length)); 
     } 

     pool.shutdown(); 
    } 

    private static class RecursiveIterate extends RecursiveAction { 

     final int start; 
     final int end; 

     public RecursiveIterate(final int start, final int end) { 
      this.start = start; 
      this.end = end; 
     } 

     @Override 
     protected void compute() { 

      if ((end - start) <= (intArray.length/TASKS)) { 
       // We've reached the subdivision limit - iterate over the arrays 
       for (int i = start; i < end; i += 3) { 
        floatArray[i] += i + intArray[i]; 
       } 

      } else { 
       // Subdivide and start new tasks 
       final int mid = (start + end) >>> 1; 
       invokeAll(new RecursiveIterate(start, mid), new RecursiveIterate(mid, end)); 
      } 
     } 
    } 
}

来源

2011-03-30 AaronD

看起来它是按照设计工作。您正在请求1的并行性，但是您在invokeAll中添加了两个任务。但我不是这方面的专家，所以我可能是错的。 – 2011-03-31 00:56:51

我以前从其他人那里听说过，将线程数设置为“多一个”会修复一些问题。 – 2011-03-31 01:11:11

回复：Jochen - 据我了解框架，我们应该能够添加任意数量的任务，而不管并行性级别（线程数量）。例如，我们可以递归地将一个大任务细分成256个独立的小任务，但是我们应该能够在少于256个处理器的机器上执行该算法。另外，死锁不是直接的（正如我们所期望的那样，如果2个任务/ 1个线程是非法的 - 相反它是在迭代次数不可预知的情况下发生的，但是我对FJ也是比较新颖的，所以我可能会误解。 – AaronD 2011-03-31 03:40:34

看起来像在ForkJoinPool中的错误。所有我能在课堂上看到的东西都适合你的例子。唯一的另一种可能性可能是你的任务之一抛出异常并且异常死亡（尽管这仍然应该被处理）。

来源

2011-03-31 01:03:56 jtahlborn

这是在实际上是ForkJoinPool中的一个错误。与@axtavt相反，它可以在JDK 1.7以及JDK 1.6 + jsr166y中重现。我在一个单独的论坛中与Doug Lea讨论了这个问题，他断定ForkJoinPool过早地终止了工作线程。该修复程序现已在http://gee.cs.oswego.edu/dl/concurrency-interest/index.html中检入，并且可以在OpenJDK 1.7版本中很快获得。 – AaronD 2011-04-01 22:42:04

非常漂亮！ – jtahlborn 2011-04-01 22:56:33

ForkJoinPool并行度= 1死锁

回答

相关问题