Java多线程中正确同步 getter 与确保主线程等待子线程完成的实践指南

本文详解为何仅对 run() 和 getmax() 方法加 synchronized 无法真正解决竞态问题，并提供基于 join()、future 和线程安全封装的三种专业级解决方案。

本文详解为何仅对 run() 和 getmax() 方法加 synchronized 无法真正解决竞态问题，并提供基于 join()、future 和线程安全封装的三种专业级解决方案。

在 Java 多线程编程中，一个常见误区是认为给 run() 或 getter 方法加上 synchronized 就能“自动保证线程执行顺序”或“强制主线程等待”。但事实恰恰相反：synchronized 仅保证临界区互斥访问，不提供线程执行依赖关系（如“等待完成”语义）。原始代码的问题本质是缺少显式的线程同步机制来协调主线程与工作线程的执行时序——主线程在子线程尚未完成计算时便调用 getMax()，读取到的是未初始化或过期的 max 值（默认为 0），导致结果错误。

❌ 错误方案解析：为什么 synchronized run() 和 synchronized getMax() 是伪解？

public synchronized void run() { /* ... */ }  // ❌ 危险！串行化所有任务
public synchronized int getMax() { return max; }

• synchronized run() 会使所有 MaxTask 实例串行执行，彻底丧失并行性，违背多线程初衷；
• synchronized getMax() 仅防止多个线程同时读取 max，但无法保证读取时 max 已被正确写入（即缺乏 happens-before 关系）；
• 更关键的是：synchronized 不等价于 join() —— 它不阻塞主线程，也不声明“我必须等你跑完”。

因此，该做法属于“用错工具治错病”，表面看似“加了锁就安全”，实则掩盖了根本缺陷。

✅ 正确方案一：使用 Thread.join() 显式等待（最直接）

这是最符合原代码结构的修复方式，只需在启动所有线程后，插入等待逻辑：

// 启动所有线程后，立即 join
for (int i = 0; i < workers; i++) {
    tasks[i].start();
}
// 等待全部完成（关键！）
for (int i = 0; i < workers; i++) {
    tasks[i].join(); // 主线程在此阻塞，直到 tasks[i] 终止
}

// 此时再读取结果，100% 安全
int maxmax = tasks[0].getMax();
for (int i = 1; i < workers; i++) {
    maxmax = Math.max(maxmax, tasks[i].getMax());
}
System.out.println("maxmax=" + maxmax);

✅ 优势：语义清晰、零额外依赖、适用于简单场景。
⚠️ 注意：join() 可能抛出 InterruptedException，生产环境应合理处理（如恢复中断状态）。

✅ 正确方案二：使用 ExecutorService + Future（推荐工业级实践）

告别手动管理 Thread，改用高层抽象，兼具安全性与可扩展性：

NewsBang

盛大旗下AI团队推出的智能新闻阅读App

下载

立即学习“Java免费学习笔记（深入）”；

import java.util.concurrent.*;

public class MaxTaskCallable implements Callable<Integer> {
    private final int[] arr;
    private final int first, last;

    public MaxTaskCallable(int[] arr, int first, int last) {
        this.arr = arr;
        this.first = first;
        this.last = last;
    }

    @Override
    public Integer call() throws Exception {
        int max = arr[first];
        for (int i = first + 1; i <= last; i++) {
            if (arr[i] > max) max = arr[i];
        }
        return max;
    }
}

// Main 中调用：
ExecutorService executor = Executors.newFixedThreadPool(workers);
List<Future<Integer>> futures = new ArrayList<>();

for (int i = 0; i < workers; i++) {
    futures.add(executor.submit(new MaxTaskCallable(arr, first, last)));
    first = last + 1;
}

// 收集结果（自动等待完成）
int maxmax = Integer.MIN_VALUE;
for (Future<Integer> future : futures) {
    maxmax = Math.max(maxmax, future.get()); // get() 阻塞直至计算完成
}

executor.shutdown();
System.out.println("maxmax=" + maxmax);

✅ 优势：资源复用、异常传播明确、天然支持超时控制（future.get(5, TimeUnit.SECONDS)）、易于监控与扩展。
? 提示：Future.get() 是线程安全的，无需额外同步 getMax()。

✅ 正确方案三：线程安全的结果容器（适合复杂状态共享）

若需在运行中动态更新共享状态（如累计统计），可封装 AtomicInteger 或 ReentrantLock：

public class MaxTaskSafe extends Thread {
    private final int[] arr;
    private final int first, last;
    private final AtomicInteger result; // 线程安全容器

    public MaxTaskSafe(int[] arr, int first, int last, AtomicInteger result) {
        this.arr = arr;
        this.first = first;
        this.last = last;
        this.result = result;
    }

    @Override
    public void run() {
        int localMax = arr[first];
        for (int i = first + 1; i <= last; i++) {
            if (arr[i] > localMax) localMax = arr[i];
        }
        result.accumulateAndGet(localMax, Math::max); // 原子更新最大值
    }
}

// 使用：
AtomicInteger globalMax = new AtomicInteger(Integer.MIN_VALUE);
for (int i = 0; i < workers; i++) {
    new MaxTaskSafe(arr, first, last, globalMax).start();
    first = last + 1;
}
// 等待所有线程结束（仍需 join 或 CountDownLatch）
// ...
System.out.println("maxmax=" + globalMax.get());

总结：关键原则

遵循以上实践，你将不仅能修复当前 bug，更能构建出真正可靠、可演进的并发程序。