Java多线程 计算总数

在Java中，多线程是一种并发处理技术，允许程序同时执行多个任务，每个任务都在单独的线程中运行。如果我们要计算总数并使用多线程，通常可以设计一个场景，比如有一个大数组，需要分段进行累加操作，每个线程负责一段的计算，最后将结果汇总。

下面是一个简单的例子，展示如何使用`ExecutorService`和`Callable`来创建一个计算总和的多线程程序：

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

public class MultiThreadedSum {
    private int[] numbers;
    private int total = 0;

    public MultiThreadedSum(int[] numbers) {
        this.numbers = numbers;
    }

    public void computeTotal() throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(4); // 创建固定大小的线程池

        // 将数组分割成多个部分，并创建Callable任务来计算每部分的和
        Future<Integer>[] futures = new Future[numbers.length / 4];
        for (int i = 0; i < futures.length; i++) {
            int start = i * 4;
            int end = Math.min(start + 4, numbers.length);
            futures[i] = executor.submit(new SumTask(numbers, start, end));
        }

        // 等待所有任务完成并收集结果
        for (Future<Integer> future : futures) {
            total += future.get(); // 线程安全地累加结果
        }

        executor.shutdown();
    }

    // Callable任务，用于计算给定范围内的和
    static class SumTask implements Callable<Integer> {
        private final int[] numbers;
        private final int start;
        private final int end;

        public SumTask(int[] numbers, int start, int end) {
            this.numbers = numbers;
            this.start = start;
            this.end = end;
        }

        @Override
        public Integer call() {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += numbers[i];
            }
            return sum;
        }
    }

    public int getTotal() {
        return total;
    }

    // 示例用法
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        MultiThreadedSum calculator = new MultiThreadedSum(numbers);
        try {
            calculator.computeTotal();
            System.out.println("Total calculated in parallel: " + calculator.getTotal());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们创建了一个`MultiThreadedSum`类，它有一个`computeTotal()`方法，这个方法创建了固定数量的工作线程来分段计算数组的和，然后汇总这些结果。`SumTask`是实现了`Callable`接口的内部类，用于封装单个线程的任务。