Java多线程矩阵乘法性能问题排查

嘿，我来帮你拆解下这段代码的性能问题，以及怎么优化它～

核心问题分析 #

从你给出的代码片段来看，最明显的性能瓶颈就是这行：

private final static int NUM_OF_THREAD =1 ;

线程数设置为1，相当于完全没用到多线程的优势，和单线程执行矩阵乘法没区别，完全浪费了多核CPU的性能。除此之外，还有几个潜在的性能坑需要注意：

• 任务拆分不合理：如果后续代码里的任务拆分粒度太粗（比如一个线程扛整个矩阵）或太细（比如每个元素开一个线程），都会带来额外的调度开销
• 共享变量的同步开销：matC是全局共享变量，如果代码里对它的访问加了不必要的锁，会导致线程阻塞，拖慢整体计算速度
• 线程创建销毁的开销：如果手动创建线程，频繁的创建和销毁会消耗不少系统资源

优化方案 #

1. 合理设置线程数

线程数建议和你的CPU核心数匹配，这样能最大化利用多核资源，可以用Java自带的API动态获取：

private final static int NUM_OF_THREAD = Runtime.getRuntime().availableProcessors();

对于矩阵乘法这种CPU密集型任务，线程数设置为核心数或核心数+1就足够了，过多线程会导致上下文切换开销飙升，反而降低性能。

2. 无竞争的任务拆分

矩阵乘法里，matC的每一行计算都是独立的（只依赖matA的对应行和matB的所有列），所以可以按行拆分任务：每个线程负责计算matC的连续几行，这样线程之间完全不需要共享计算资源，也不需要加锁，彻底避免同步开销。

3. 使用线程池管理线程

手动创建线程的开销不小，推荐用ExecutorService线程池来管理线程，复用线程资源，减少创建销毁的开销：

public class MatMulConcur { 
    private final static int NUM_OF_THREAD = Runtime.getRuntime().availableProcessors();
    private static ExecutorService executor = Executors.newFixedThreadPool(NUM_OF_THREAD);

    public static Mat matmul(Mat matA, Mat matB) throws InterruptedException { 
        int rowsA = matA.getNRows();
        int colsB = matB.getNColumns();
        Mat matC = new Mat(rowsA, colsB);
        
        int rowsPerThread = rowsA / NUM_OF_THREAD;
        int remainingRows = rowsA % NUM_OF_THREAD;
        
        List<Future<?>> futures = new ArrayList<>();
        int startRow = 0;
        
        for (int i = 0; i < NUM_OF_THREAD; i++) {
            int endRow = startRow + rowsPerThread;
            if (i == NUM_OF_THREAD - 1) {
                endRow += remainingRows; // 最后一个线程处理剩余的行
            }
            // 提交任务到线程池
            futures.add(executor.submit(new MatrixMultiplier(matA, matB, matC, startRow, endRow)));
            startRow = endRow;
        }
        
        // 等待所有任务完成
        for (Future<?> future : futures) {
            future.get();
        }
        
        return matC;
    }

    // 负责计算指定行的任务类
    private static class MatrixMultiplier implements Runnable {
        private Mat matA;
        private Mat matB;
        private Mat matC;
        private int startRow;
        private int endRow;

        public MatrixMultiplier(Mat matA, Mat matB, Mat matC, int startRow, int endRow) {
            this.matA = matA;
            this.matB = matB;
            this.matC = matC;
            this.startRow = startRow;
            this.endRow = endRow;
        }

        @Override
        public void run() {
            int colsA = matA.getNColumns();
            int colsB = matB.getNColumns();
            for (int i = startRow; i < endRow; i++) {
                for (int j = 0; j < colsB; j++) {
                    double sum = 0;
                    for (int k = 0; k < colsA; k++) {
                        sum += matA.get(i, k) * matB.get(k, j);
                    }
                    matC.set(i, j, sum);
                }
            }
        }
    }
}

4. 额外优化点

• 矩阵存储优化：如果Mat类用二维数组存储，建议用行优先的方式访问（和代码里的循环顺序一致），减少CPU缓存失效，提升缓存命中率
• 避免全局共享变量：把matC作为局部变量传入任务类，而不是全局静态变量，避免潜在的线程安全问题和并发冲突

内容的提问来源于stack exchange，提问作者mc29