Java多线程查找数组最大值：join()必要性及性能优化问询

问题分析与解决方案 #

先拆解你的几个核心疑问，再给出针对性的优化方案：

1. 为什么不用join()得不到正确结果？

当你启动子线程后，主线程和子线程是并行执行的。如果不调用join()，主线程会直接跳过等待逻辑，立刻去读取threadMax的值——但这时候子线程可能还没完成数组遍历计算，threadMax还是int类型的默认初始值0，自然得不到正确的局部最大值，最终汇总的全局结果也就错了。join()的核心作用就是让主线程暂停，等待当前子线程执行完毕后再继续，确保你读取的是计算完成后的有效结果。

2. 为什么用了join()后和单线程速度差不多？

看你的原代码，你是启动一个线程就立刻调用join()，这相当于强制四个线程串行执行：第一个线程跑完，才启动第二个并等待它结束，以此类推。完全没有利用多线程并行执行的优势，和单线程从头到尾遍历数组的效率当然几乎一致。

正确的多线程实现方式 #

要真正发挥多线程的性能优势，你需要先把所有线程都启动起来，让它们并行处理各自的数组片段，等所有线程都执行完毕后再汇总结果。修改后的主程序代码如下：

public static void main(String[] args) {
    // 假设这里已初始化目标数组array
    ThreadMax[] findMax = new ThreadMax[4];
    findMax[0] = new ThreadMax(array, 0, array.length/4);
    findMax[1] = new ThreadMax(array, array.length/4, (2*array.length)/4);
    findMax[2] = new ThreadMax(array, (2*array.length)/4, (3 * array.length) / 4);
    findMax[3] = new ThreadMax(array, (3 * array.length) / 4, array.length);

    // 第一步：批量启动所有线程，让它们并行执行
    for(int i = 0; i < 4; i++) {
        findMax[i].myThread.start();
    }

    // 第二步：统一等待所有线程执行完毕
    for(int i = 0; i < 4; i++) {
        try {
            findMax[i].myThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    // 第三步：汇总局部最大值得到全局结果
    int result = Integer.MIN_VALUE; // 改用最小值初始化，避免数组全为负数时出错
    for(int i = 0; i < 4; i++){
        if(result < findMax[i].threadMax)
            result = findMax[i].threadMax;
    }
    System.out.println("Max = " + result);
}

这样修改后，四个线程会同时遍历各自的数组片段，真正实现并行计算，只有在所有线程完成后才汇总结果，执行速度会比单线程版本快很多（尤其当数组规模极大时）。

更优雅的替代方案：使用Callable+ExecutorService #

手动管理线程和join()会比较繁琐，Java提供了更高级的并发工具类。你可以用Callable定义带返回值的任务，配合ExecutorService线程池执行，无需手动处理线程生命周期：

import java.util.concurrent.*;

public class MaxFinder {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int[] array = { /* 你的数组数据 */ };
        int threadCount = 4;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        Future<Integer>[] futures = new Future[threadCount];

        for (int i = 0; i < threadCount; i++) {
            int start = i * array.length / threadCount;
            int end = (i + 1) * array.length / threadCount;
            // 处理数组长度无法被4整除的边界情况
            if (i == threadCount - 1) {
                end = array.length;
            }
            futures[i] = executor.submit(new FindMaxTask(array, start, end));
        }

        // 汇总结果：future.get()会自动等待任务完成
        int result = Integer.MIN_VALUE;
        for (Future<Integer> future : futures) {
            int localMax = future.get();
            if (localMax > result) {
                result = localMax;
            }
        }

        System.out.println("Max = " + result);
        executor.shutdown(); // 关闭线程池
    }

    static class FindMaxTask implements Callable<Integer> {
        private int[] array;
        private int start;
        private int end;

        public FindMaxTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

        @Override
        public Integer call() {
            int max = Integer.MIN_VALUE;
            for (int i = start; i < end; i++) {
                if (array[i] > max) {
                    max = array[i];
                }
            }
            return max;
        }
    }
}

这个方案的优势：

• 无需手动管理线程创建和join()，future.get()会自动等待任务完成
• 线程池可复用线程，避免频繁创建销毁线程的开销
• 用Integer.MIN_VALUE初始化最大值，解决了原代码中数组全为负数时结果错误的问题

补充说明 #

多线程提升性能的前提是数组规模足够大，如果数组很小，线程创建和上下文切换的开销可能会超过并行计算带来的收益，此时单线程反而更快。建议在数组元素数量较多时再使用多线程方案。

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