如何在Compute()方法中对类的列表进行迭代扩展RecursiveAction/RecursiveTask

Question

我尝试了许多方法来获得以下方案的工作，结果是无限打印分叉分叉..我试着调试，但它总是在task.join();中等待很长一段时间，没有结果。我很好地理解了fork/join的概念，当我的任务可以分成几个子部分时，我可以使用它，比如:斐波那契数组和最大数组。这里的场景是不同的，因为我必须在计算中进行迭代，这不是递归的。有人能帮上忙吗？

CompositePoolTest

 import java.util.Random;
 import java.util.concurrent.ForkJoinPool;

 public class CompositePoolTest {

Random random = new Random(123);
int done = 0;
int rest= 0;
int tt = 4;
ForkJoinPool pool = new ForkJoinPool(tt);
int M= 1000;
int N = 1000;

public static void main(String[] args) {
    new CompositePoolTest().compute();
}

private void compute() {
    double[][] original_matrix = new double[M][N];
    original_matrix = radom_intialization();
    double[][] temp_matrix = new double[M][N];
    done= 0;
    rest= (M * N - done) / (tt- 0);
    DynamicCompositeFinder dynamicFinder = new DynamicCompositeFinder(done,rest,original_matrix,temp_matrix);
    new ForkJoinPool().invoke(dynamicFinder);
}

private double[][] radom_intialization() {
    double [][] grid_matrix = new double[M][N];
    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++) {
            grid_matrix[i][j] = random.nextDouble()+0.10;
        }
    return grid_matrix;
}
 }

DynamicCompositeFinder

package test;

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

    public class DynamicCompositeFinder extends RecursiveAction {
int done = 0;
int rest = 0;
int pp = 4;
ForkJoinPool pool = new ForkJoinPool(pp);
// Matrix dimensions
int M = 1000;
int N = 1000;
int x = 0;
int y = 0;
int niteration = 150;
double[][] original_matrix = new double[M][N];
double[][] temp_matrix = new double[M][N];

public DynamicCompositeFinder(int done, int rest, double[][] original_matrix, double[][] temp_matrix) {
    this.done = done;
    this.rest = rest;
    this.original_matrix = original_matrix;
    this.temp_matrix = temp_matrix;

    int limit = done + rest;
    for (int i = done; i < limit; i++) {
        x = i / M;
        y = i % M;
        temp_matrix[x][y] = fun_calculation(x, y, original_matrix);
    }
}

private double fun_calculation(int x2, int y2, double[][] original_matrix2) {
     double temp = 2 * (original_matrix2[x][y] );
    return temp;
}

@Override
protected void compute() {
    for (int i = 0; i < niteration; i++) {
        done = 0;
        List<RecursiveAction> forks = new LinkedList<RecursiveAction>();
        for (int p = 0; p < pp; p++) // n is predefined n = 9
        {
            rest = (M * N - done) / (pp - p);
            DynamicCompositeFinder finder = new DynamicCompositeFinder(done, rest, original_matrix, temp_matrix);
            p++;
            forks.add((RecursiveAction) finder.fork());
            System.out.println("Fork-" + Thread.currentThread().getName()
                    + "  State: " + Thread.currentThread().getState());
        }

        for (RecursiveAction task : forks) {
            task.join();
            System.out.println("Join-" + Thread.currentThread().getName()
                    + "  State: " + Thread.currentThread().getState());
        }
        original_matrix = copy_matrix(temp_matrix);
    }
}

public double[][] copy_matrix(double [][] matrix)
{
    double [][] out= new double [matrix.length][matrix[0].length];
    for(int i=0;i<matrix.length;i++)
    {
        out[i]= matrix[i].clone();
    }
    return out;
}}

输出

Fork-ForkJoinPool-1-worker-1  State: RUNNABLE
Fork-ForkJoinPool-1-worker-1  State: RUNNABLE
Fork-ForkJoinPool-1-worker-2  State: RUNNABLE
Fork-ForkJoinPool-1-worker-2  State: RUNNABLE
Fork-ForkJoinPool-1-worker-3  State: RUNNABLE
Fork-ForkJoinPool-1-worker-4  State: RUNNABLE
Fork-ForkJoinPool-1-worker-4  State: RUNNABLE
Fork-ForkJoinPool-1-worker-3  State: RUNNABLE
Fork-ForkJoinPool-1-worker-5  State: RUNNABLE
Fork-ForkJoinPool-1-worker-5  State: RUNNABLE
Fork-ForkJoinPool-1-worker-6  State: RUNNABLE
Fork-ForkJoinPool-1-worker-6  State: RUNNABLE
Fork-ForkJoinPool-1-worker-7  State: RUNNABLE
Fork-ForkJoinPool-1-worker-7  State: RUNNABLE
Fork-ForkJoinPool-1-worker-8  State: RUNNABLE
Fork-ForkJoinPool-1-worker-8  State: RUNNABLE
Fork-ForkJoinPool-1-worker-9  State: RUNNABLE
Fork-ForkJoinPool-1-worker-9  State: RUNNABLE
Fork-ForkJoinPool-1-worker-10  State: RUNNABLE
Fork-ForkJoinPool-1-worker-10  State: RUNNABLE
Fork-ForkJoinPool-1-worker-11  State: RUNNABLE
Fork-ForkJoinPool-1-worker-11  State: RUNNABLE
Fork-ForkJoinPool-1-worker-12  State: RUNNABLE
Fork-ForkJoinPool-1-worker-12  State: RUNNABLE
Fork-ForkJoinPool-1-worker-13  State: RUNNABLE
.....
......

Answer 1

主要的问题是你永远使用fork()。没有停止代码，例如: if (computed < limiter) return；因此，您将任务添加到deque，线程将获取每个任务并永远派生更多任务。我在您的代码中添加了一个拦截器，并在Java7中运行它。join()会被调用，但外部迭代会一直进行下去。所以你有一些逻辑上的问题。

第二个问题是你误解了F/J框架。这个框架不是一个通用的并行引擎。它是专为递归遍历平衡树的叶子而设计的学术代码(D.A.G.)由于您没有平衡树，因此您无法根据JavaDoc中给出的示例进行处理: split left，right；left.fork()；right.compute()；left.join()；并且您没有进行递归分解。您的代码更适合Java8的CountedCompler()