本文详解如何在多线程求最大值场景中，通过合理使用join()与线程安全设计（而非错误依赖synchronized run）确保主线程等待子线程完成，避免竞态读取未初始化结果。
本文详解如何在多线程求最大值场景中，通过合理使用`join()`与线程安全设计（而非错误依赖`synchronized run`）确保主线程等待子线程完成，避免竞态读取未初始化结果。
在Java并发编程中，一个常见误区是试图用synchronized修饰run()方法或getter来“强制等待”子线程执行完毕。但正如示例代码所示：MaxTask类中将run()和getMax()同时加synchronized看似能“修复”结果不一致问题，实则掩盖了根本缺陷——它并未解决线程生命周期同步问题，反而引入了严重性能退化与逻辑混淆。
❌ 为什么synchronized run()是错误解法？
run()方法被synchronized修饰后，意味着所有MaxTask实例共享同一把锁（默认为this对象锁）。由于每个线程调用的是各自实例的run()，该同步仅在多个线程竞争调用同一个实例的run()时生效——而本例中每个线程运行的是独立实例，因此synchronized run()完全不起作用。若误以为它实现了串行执行，实属对锁作用域的误解。
更危险的是：即使通过其他方式（如静态锁）强行让run()串行化，也彻底违背了多线程并行计算的初衷，使10个线程退化为单线程遍历，性能不升反降。
✅ 正确解法：显式等待 + 线程安全结果封装
核心原则是：主线程必须主动等待所有工作线程结束，再读取结果。推荐使用Thread.join()——它阻塞当前线程，直到目标线程终止。
立即学习“Java免费学习笔记（深入）”；
以下是重构后的专业实现：
public class MaxTask extends Thread {
private final int[] arr;
private final int first, last;
private volatile int max; // 使用volatile保证可见性（非必需但更健壮）
public MaxTask(int[] arr, int first, int last) {
this.arr = arr;
this.first = first;
this.last = last;
}
@Override
public void run() {
if (first > last || first >= arr.length || last < 0) return;
max = arr[first];
for (int i = first + 1; i <= last && i < arr.length; i++) {
if (arr[i] > max) max = arr[i];
}
}
public int getMax() {
return max; // 不需要synchronized：join后读取已安全
}
}public class MainMax {
public static void main(String[] args) throws InterruptedException {
int size = 100;
int workers = 10;
int[] arr = new int[size];
// 初始化数组...
for (int i = 0; i < size; i++) {
arr[i] = (int) (Math.random() * 100);
}
int gsize = Math.max(1, (size - 1) / workers); // 防止除零/过小分片
MaxTask[] tasks = new MaxTask[workers];
// 启动所有线程
int first = 0;
for (int i = 0; i < workers; i++) {
int last = Math.min(first + gsize, size - 1);
tasks[i] = new MaxTask(arr, first, last);
tasks[i].start();
first = last + 1;
}
// ✅ 关键：主线程等待所有子线程完成
for (MaxTask task : tasks) {
task.join(); // 阻塞直到task执行完毕
}
// 此时所有max均已计算完成，可安全读取
int maxmax = tasks[0].getMax();
for (int i = 1; i < tasks.length; i++) {
int temp = tasks[i].getMax();
if (temp > maxmax) maxmax = temp;
}
System.out.println("maxmax=" + maxmax);
}
}⚠️ 重要注意事项
- join()是标准且最轻量的同步机制：无需额外锁，语义清晰，开销极小；
- volatile提升健壮性：虽join()本身已建立happens-before关系，保证结果可见性，但为max字段添加volatile可进一步防御潜在JIT优化风险；
- 边界检查不可省略：原代码中last = first + gsize可能越界，需用Math.min(last, size-1)防护；
- 线程数≠越多越好：workers=10对size=100明显过度；应根据CPU核心数与任务粒度权衡，通常Runtime.getRuntime().availableProcessors()是更合理的起点；
- 现代替代方案：对于此类归约操作，强烈推荐使用ForkJoinPool或CompletableFuture，它们自动处理线程调度、异常传播与结果聚合，代码更简洁可靠。
总结
解决“主线程过早读取子线程结果”的本质，不是给方法加synchronized，而是正确管理线程生命周期。Thread.join()是直击要害的标准方案。摒弃滥用同步的思维惯性，回归并发模型的本质约束，才能写出高效、可维护、真正正确的多线程代码。
