如何使用多线程在java中找到二维数组的最大值

我想找到二维数组的最大值。我在没有使用多线程的情况下找到了这个值。如何使用多线程来查找二维数组的最大值？我想比较以不同方式找到数组最大值的速度

public class Search {

    public int[][] fillMatrix(int matrix[][]) {
        for (int i = 0; i < matrix.length; i++){
            for (int j = 0; j < matrix[i].length; j++){
              matrix[i][j] = (int)(Math.random() * 1000);
            }
        }
        return matrix;
    }

    public int searchMaxValue(int[][] matrix, int row, int column) {
        int max = matrix[0][0];
        for (int a = 0; a < row; a++) {
            for (int b = 0; b < column; b++) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (matrix[a][b] > max) {
                    max = matrix[a][b];
                }
            }
        }
        return max;
    }


    public static void main(String[] args) {

        Search search = new Search();
        int[][] matrix = new int[4][100];
        search.fillMatrix(matrix);
        long start = System.currentTimeMillis();
        int max = search.searchMaxValue(matrix, 4, 100);
        long end = System.currentTimeMillis();
        System.out.println("Max value is " + max);
        System.out.println("Time for execution: " + (end - start));
    }
}

公共类搜索{
公共整数[][]填充矩阵（整数矩阵[][]{
对于（int i=0；i最大值）{
max=矩阵[a][b]；
}
}
}
返回最大值；
}
公共静态void main（字符串[]args）{
搜索=新搜索（）；
int[][]矩阵=新int[4][100]；
搜索。填充矩阵（矩阵）；
长启动=System.currentTimeMillis（）；
int max=search.searchMaxValue（矩阵，4100）；
long end=System.currentTimeMillis（）；
System.out.println（“最大值为”+Max）；
System.out.println（“执行时间：+（结束-开始））；
}
}

最简单的方法是启动一个线程来计算矩阵中四行中每一行的最大值，让主线程连接所有这些行线程并计算四行最大值中的最大值。不过，您可能需要更大的阵列才能看到时差。不要忽略必要的同步

---

如果我怀疑您正在寻找代码，那么您应该尝试使用该解决方案并运行它，然后重新发布或详细说明您遇到的问题。

以下是如何在java 8中执行此操作：

int[][] values = fillMatrix(new int[1000][1000]);
OptionalInt max = Arrays.stream(values)
    .parallel()
    .flatMapToInt(Arrays::stream)
    .parallel()
    .max();

但坦率地说，我不确定对于如此简单的计算来说，使用几个线程是否有意义，事实上，在这种情况下，创建和编排线程的代价似乎太高了

响应更新

由于这是您的家庭作业，我特意提供了一个没有任何注释的答案，以确保您至少会思考它是如何工作的，但主要思想是为每个线程提供数据块，以避免下一个线程发生冲突：

int[][] matrix = fillMatrix(new int[100][100]);
int totalThreads = 10;
int[] results = new int[totalThreads];
int chunkSize = matrix.length / totalThreads;
CountDownLatch end = new CountDownLatch(totalThreads);
for (int i = 0; i < totalThreads; i++) {
    int threadIndex = i;
    new Thread(
        () -> {
            int max = -1;
            int startIndex = threadIndex * chunkSize;
            for (int j = startIndex; j < startIndex + chunkSize && j < matrix.length; j++) {
                for (int k = 0; k < matrix[j].length; k++) {
                    if (max == -1 || max <  matrix[j][k]) {
                        max = matrix[j][k];
                    }
                }
            }
            results[threadIndex] = max;
            end.countDown();
        }
    ).start();
}
end.await();
int max = results[0];
for (int k = 1; k < results.length; k++) {
    if (max < results[k]) {
        max = results[k];
    }
}
System.out.printf("Max found %d%n", max);

int[][]矩阵=填充矩阵（新的int[100][100]）；
int totalThreads=10；
int[]结果=新的int[totalThreads]；
int chunkSize=matrix.length/totalThreads；
CountDownLatch end=新的CountDownLatch（totalThreads）；
对于（inti=0；i {
int max=-1；
int startIndex=threadIndex*chunkSize；
对于（int j=startIndex；j

以下是您将如何实现此功能的概要。我不是故意提供代码，这样您就可以享受自己实现代码的乐趣

创建一个从数组中查找最大值的方法，让我们调用它

findmax（int[]
输入）

对于2D数组中的每个子数组（可使用

矩阵[i]

访问）
启动一个线程以

findMax（矩阵[i]）

（提示：使用

ExecutorService

） 在螺纹中，一旦找到最大值，将其填入

i

th位置 对于线程中名为

results

的一维数组，指示 它的完成（提示：使用

倒计时闩锁

）

在主线程中，等待所有线程完成（提示：使用

CountDownLatch

）现在调用

findMax（results）

，您就有了 矩阵的最大值

---

注意事项：我们是否需要像矩阵中的行一样多地分叉线程？那么，我们是否使用具有行数的

FixedThreadPool

？

这个想法是为每个内部数组（aka

column

）启动一个新线程，该数组查找最大值，返回最大值并结束。然后，主线程将只在所有这些值中查找最大值，从而提高多核CPU的速度。thouguh，这将允许他获得家庭作业问题的答案。谢谢，你的方法很好，但我需要使用上面答案中指定的方法解决问题。沃伦·德鲁是对的，这是我的家庭作业。lambda是胶水代码。请不要在lambdas中编写整个方法。GoogleLambdas是胶水代码，阅读了Venkat的一些优秀见解Subramaniam@ringbearer这只是为了说明这个想法而已，Lambda非常适合这一点，我们需要在矩阵MxN中找到M个线程的最大值。我们不使用FixedThread池。