带参数传递的Java并行for循环

我希望Java 1.8中的代码在更多处理器上并行运行：

        // Make iterations
        for(int i = 0; i < numberOfIterations; i++) {
            for(int m = 0; m < gridsize; m++) {
                for(int n = 0; n < gridsize; n++) {
                    one_cell_generation(grid, grid2, m, n);
                }
                int n = 0;
            }

        }

---

外环是一个时间序列，在不同的代上循环，因此不能并行化而不影响最终结果

这两个内环根据上一代的状态计算当前一代的状态，并且很容易并行化

以下是一种使用以下方法的方法：

static int numberOfIterations=100；
静态int gridSize=5；
公共静态void main（字符串[]args）{
布尔值[][]grid1=新的布尔值[gridSize][gridSize]；
Boolean[][]grid2=新的Boolean[gridSize][gridSize]；
//在此初始化网格
对于（int i=0；i{
int m=mn/gridSize；
int n=mn%gridSize；
一代细胞（grid1，grid2，m，n）；
});
//在此处将新网格复制到旧网格
}
}
公共静态void oneCellGeneration（布尔值[][]grid1，布尔值[][]grid2，
整数m，整数n）{
//你的细胞生成逻辑在这里
}

---

注1:我重命名了一些方法和变量，以符合Java命名约定。

---

注意2:在原始代码中完成一代之后（或开始之前），您忘记将新网格复制到旧网格。

您可以这样做。我不能在答案中添加答案，所以我创建了自己的答案

    static int gridSize = 5;

    public static void main(String[] args) {
        Boolean[][] grid1 = new Boolean[gridSize][gridSize];
        Boolean[][] grid2 = new Boolean[gridSize][gridSize];

        // initialize grids here

            IntStream
                    .range(0, gridSize * gridSize)
                    .limit(numberOfIterations)
                    .parallel().forEach(mn -> {
                int m = mn / gridSize;
                int n = mn % gridSize;

                oneCellGeneration(grid1, grid2, m, n);
            });
    }

    public static void oneCellGeneration(Boolean[][] grid1, Boolean[][] grid2,
                                         int m, int n) {
        // your cell generation logic here
    }
    ```

---

到目前为止你都尝试了什么？我不知道《生活游戏》的确切代码，但是看看你在这里粘贴的内容，有很多机会并发修改执行在这种情况下你会怎么做？这不像添加一些线程那么容易。关于这个话题已经有很多文章了。回答这个问题对于StackOverflow来说是不合适的，因为它本质上意味着重组整个程序。即使程序在并行运行时能按预期工作，也不能保证它能减少执行时间。我最好的提示是：开始阅读，我不需要收藏。可以轻松使用

IntStream

在二维数组上迭代。@Vault23

liveneights

变量是该方法的局部变量。每个线程都有自己的副本。没有风险，没有瓶颈。

static int numberOfIterations = 100;
static int gridSize = 5;

public static void main(String[] args) {
    Boolean[][] grid1 = new Boolean[gridSize][gridSize];
    Boolean[][] grid2 = new Boolean[gridSize][gridSize];

    // initialize grids here

    for(int i = 0; i < numberOfIterations; i++) {
        // parallel processing
        IntStream.range(0, gridSize * gridSize).parallel().forEach(mn -> {
            int m = mn / gridSize;
            int n = mn % gridSize;

            oneCellGeneration(grid1, grid2, m, n);
        });

        // copy new grid to old grid here
    }
}

public static void oneCellGeneration(Boolean[][] grid1, Boolean[][] grid2,
        int m, int n) {
    // your cell generation logic here
}

    static int gridSize = 5;

    public static void main(String[] args) {
        Boolean[][] grid1 = new Boolean[gridSize][gridSize];
        Boolean[][] grid2 = new Boolean[gridSize][gridSize];

        // initialize grids here

            IntStream
                    .range(0, gridSize * gridSize)
                    .limit(numberOfIterations)
                    .parallel().forEach(mn -> {
                int m = mn / gridSize;
                int n = mn % gridSize;

                oneCellGeneration(grid1, grid2, m, n);
            });
    }

    public static void oneCellGeneration(Boolean[][] grid1, Boolean[][] grid2,
                                         int m, int n) {
        // your cell generation logic here
    }
    ```