Java多线程数值统计场景下如何将线程迁移至独立计算类调用

核心思路 #

• 将三个计算逻辑分别封装为独立的Runnable实现类（即需求中的「计算类」），完全剥离对主类静态变量的依赖，降低耦合度
• 每个计算类通过构造方法传入待计算的整数数组，内部存储计算结果，提供专属的取值方法供外部获取最终结果
• 主类仅保留用户输入收集、线程调度、结果打印的逻辑，职责更清晰

独立计算类实现 #

三个计算类可以写在同一个Java文件里，也可以单独拆分为三个文件，以下是实现代码：

// 平均值计算类
class AvgCalculator implements Runnable {
    private final int[] input;
    private double average;

    public AvgCalculator(int[] input) {
        this.input = input;
    }

    @Override
    public void run() {
        double sum = 0;
        for (int num : input) {
            sum += num;
        }
        this.average = sum / input.length;
    }

    public double getAverage() {
        return average;
    }
}

// 最大值计算类
class MaxCalculator implements Runnable {
    private final int[] input;
    private int max;

    public MaxCalculator(int[] input) {
        this.input = input;
    }

    @Override
    public void run() {
        int maxVal = input[0];
        for (int num : input) {
            if (num > maxVal) {
                maxVal = num;
            }
        }
        this.max = maxVal;
    }

    public int getMax() {
        return max;
    }
}

// 最小值计算类
class MinCalculator implements Runnable {
    private final int[] input;
    private int min;

    public MinCalculator(int[] input) {
        this.input = input;
    }

    @Override
    public void run() {
        int minVal = input[0];
        for (int num : input) {
            if (num < minVal) {
                minVal = num;
            }
        }
        this.min = minVal;
    }

    public int getMin() {
        return min;
    }
}

改造后主类代码 #

import java.util.Scanner;

public class Stats {
    public static void main(String[] args) {
        // 收集用户输入
        Scanner scan = new Scanner(System.in);
        System.out.println("请问你要计算多少个数字？");
        int x = scan.nextInt();
        int[] input = new int[x];
        System.out.println("请输入要计算的数字：");
        for (int i = 0; i < x; i++) {
            input[i] = scan.nextInt();
        }
        scan.close();

        // 实例化计算类和对应线程
        AvgCalculator avgCalc = new AvgCalculator(input);
        Thread avgThread = new Thread(avgCalc);

        MinCalculator minCalc = new MinCalculator(input);
        Thread minThread = new Thread(minCalc);

        MaxCalculator maxCalc = new MaxCalculator(input);
        Thread maxThread = new Thread(maxCalc);

        // 启动线程
        avgThread.start();
        minThread.start();
        maxThread.start();

        // 等待所有线程执行完成
        try {
            avgThread.join();
            minThread.join();
            maxThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 打印结果
        System.out.printf("平均值：%f\n最小值：%d\n最大值：%d\n", 
                avgCalc.getAverage(), minCalc.getMin(), maxCalc.getMax());
    }
}

说明 #

改造后所有计算逻辑完全独立，不需要依赖静态变量传递数据，避免了原代码的线程安全隐患，后续如果需要新增求和、中位数等计算逻辑，只需要新增对应Runnable实现类即可，扩展性更强。

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