大厂面试题:写一个1加到100求和的类，五分钟内完成。怎么才能写出即简单又高深的实现?

本文链接：https://blog.csdn.net/qq_37477317/article/details/140642831

这个笔试题还是比较能检查出面试者的java的基础，如果有一定的java基础且有过一定的研究，这道题还是比较简单，但是，如果对多线程理解不深，则面试结果就不会理想。

对于这个具体实现，显然是有2种，一种是常规的for循环，另一种则是多线程。

第一种是保底的实现，就是for循环。

这个应该是大家直观可以想到的。

public class SumOfNumbers {    public static void main(String[] args) {        int sum = 0;        for (int i = 1; i <= 100; i++) {            sum += i;        }        System.out.println("Sum from 1 to 100 is: " + sum);    }}

这个实现就不需要过多解释了，入门级实现。

第二种，使用线程池方式实现累加

线程池实现直接将难度提高至90分了。

目前线程池有好多种，比如:

newFixedThreadPool(int n): 创建一个固定大小的线程池。
newCachedThreadPool(): 创建一个可缓存的线程池。
newSingleThreadExecutor(): 创建一个单线程的线程池。
newScheduledThreadPool(int n): 创建一个支持定时和周期性任务的线程池。

当前的需求固定就是数量100，所以，我们可以确定了，就用固定大小的线程池就可以。

线程池的种类选择好了，然后就需要确定使用哪种具体API，因为我们是需要聚合计算，这一点很重要。另外，多线程环境下需要注意线程安全的问题。

直接看实现:

public class Demo1 {
  // 使用ReentrantLock来保护对共享资源的访问
    private static final Lock lock = new ReentrantLock();
    private static int totalSum = 0;

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        /**
         * 创建一个固定大小的线程池 [100个总数】 所以线程池就是平分来算
         */
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        // 创建任务列表
        List<Callable<Integer>> tasks = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            int start = i * 10 + 1;
            int end = (i + 1) * 10;
            tasks.add(new SumTask(start, end));
        }

        // 提交所有任务并获取结果
        List<Future<Integer>> results = executorService.invokeAll(tasks);

        // 汇总结果
        for (Future<Integer> result : results) {
            lock.lock();
            try {
                totalSum += result.get();
            } finally {
                lock.unlock();
            }
        }

        // 关闭线程池
        executorService.shutdown();

        System.out.println("累加到100的结果: " + totalSum);
    }

    // 任务类，实现Callable接口
    static class SumTask implements Callable<Integer> {
        private final int start;
        private final int end;

        SumTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

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

这个就是多线程实现版本，代码可以直接跑。

这里面有几个关键点:

使用10个线程处理，每个线程分表处理10个数的和。然后再统计对10个结果的和进行累加。

因为需要返回线程结果，所以，使用Future。

比如

1到10，由线程1处理。

11到20，由线程2处理

以此类推