Java多线程执行单任务结果异常问题排查与优化咨询

问题根源 #

你遇到的偶发错误，核心原因是静态变量count在多线程环境下缺乏同步保护。多个线程会同时读取、修改count的值，导致子任务的区间分配逻辑混乱：比如线程A刚把count更新为51，线程B可能已经读取了更新前的count值，最终出现两个线程重复计算同一区间、或者跳过部分数值的情况，导致总和错误。

设置线程优先级、休眠、停止线程这些操作，只是改变了线程的执行时机，无法从根本上解决多线程对共享变量的并发访问冲突，因此偶发错误依然会出现。

最优解决方案：给线程分配固定子任务 #

让每个线程负责固定区间的求和任务，完全避免共享可变状态，从根源上消除线程安全问题。以下提供两种实现方式：

方式1：自定义Runnable+原子类汇总结果 #

通过构造函数给每个线程传入固定的计算区间，用AtomicInteger原子类安全汇总各线程的计算结果：

import java.util.concurrent.atomic.AtomicInteger;

// 自定义求和任务，每个实例处理固定区间
class FixedRangeSumTask implements Runnable {
    private final int start;
    private final int end;
    private final AtomicInteger totalSum;

    public FixedRangeSumTask(int start, int end, AtomicInteger totalSum) {
        this.start = start;
        this.end = end;
        this.totalSum = totalSum;
    }

    @Override
    public void run() {
        int subSum = 0;
        for (int i = start; i <= end; i++) {
            subSum += i;
        }
        // 原子操作累加，避免并发修改冲突
        totalSum.addAndGet(subSum);
    }
}

public class MultiThreadSumDemo {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger totalSum = new AtomicInteger(0);

        // 给每个线程分配固定区间
        Thread thread1 = new Thread(new FixedRangeSumTask(1, 50, totalSum));
        Thread thread2 = new Thread(new FixedRangeSumTask(51, 75, totalSum));
        Thread thread3 = new Thread(new FixedRangeSumTask(76, 100, totalSum));

        thread1.start();
        thread2.start();
        thread3.start();

        // 等待所有线程执行完毕
        thread1.join();
        thread2.join();
        thread3.join();

        System.out.println("前100个正整数的和：" + totalSum.get());
    }
}

方式2：使用ExecutorService+Callable返回结果 #

借助Java并发工具类ExecutorService管理线程，通过Callable直接返回每个线程的计算结果，代码更简洁：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ExecutorSumDemo {
    public static void main(String[] args) throws Exception {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交三个固定区间的求和任务，获取Future对象
        Future<Integer> sum1 = executor.submit(() -> calculateRangeSum(1, 50));
        Future<Integer> sum2 = executor.submit(() -> calculateRangeSum(51, 75));
        Future<Integer> sum3 = executor.submit(() -> calculateRangeSum(76, 100));

        // 汇总所有结果
        int total = sum1.get() + sum2.get() + sum3.get();
        System.out.println("前100个正整数的和：" + total);

        // 关闭线程池
        executor.shutdown();
    }

    // 工具方法：计算指定区间的和
    private static int calculateRangeSum(int start, int end) {
        int sum = 0;
        for (int i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }
}

方案优势 #

1. 无共享可变状态：每个线程独立处理固定区间，不存在并发访问冲突，天然线程安全。
2. 逻辑清晰：子任务划分明确，无需复杂的同步逻辑。
3. 扩展性强：如果需要调整线程数量或区间划分，只需修改任务参数即可。

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