2025.11.4学习日记

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPoolSum {

    public static void main(String[] args) throws Exception {
        // 方法1：使用Callable和Future
        System.out.println("方法1结果：" + sumWithCallable());

        // 方法2：使用CompletableFuture
        System.out.println("方法2结果：" + sumWithCompletableFuture());

        // 方法3：使用分治策略
        System.out.println("方法3结果：" + sumWithDivideAndConquer());
    }

    // 方法1：使用Callable和Future
    public static int sumWithCallable() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        int chunkSize = 10; // 每个任务处理10个数字
        int taskCount = 10; // 总共10个任务

        List<Future<Integer>> futures = new ArrayList<>();

        for (int i = 0; i < taskCount; i++) {
            final int start = i * chunkSize + 1;
            final int end = (i + 1) * chunkSize;

            Callable<Integer> task = () -> {
                int sum = 0;
                for (int j = start; j <= end; j++) {
                    sum += j;
                }
                return sum;
            };

            futures.add(executor.submit(task));
        }

        int totalSum = 0;
        for (Future<Integer> future : futures) {
            totalSum += future.get();
        }

        executor.shutdown();
        return totalSum;
    }

    // 方法2：使用CompletableFuture
    public static int sumWithCompletableFuture() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);

        List<CompletableFuture<Integer>> futures = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            final int start = i * 10 + 1;
            final int end = (i + 1) * 10;

            CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                int sum = 0;
                for (int j = start; j <= end; j++) {
                    sum += j;
                }
                return sum;
            }, executor);

            futures.add(future);
        }

        CompletableFuture<Void> allFutures = CompletableFuture.allOf(
                futures.toArray(new CompletableFuture[0])
        );

        CompletableFuture<Integer> totalFuture = allFutures.thenApply(v ->
                futures.stream()
                        .map(CompletableFuture::join)
                        .reduce(0, Integer::sum)
        );

        int result = totalFuture.get();
        executor.shutdown();
        return result;
    }

    // 方法3：使用分治策略和原子操作
    public static int sumWithDivideAndConquer() throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        AtomicInteger totalSum = new AtomicInteger(0);

        int tasks = 5; // 分成5个任务
        int numbersPerTask = 20;

        CountDownLatch latch = new CountDownLatch(tasks);

        for (int i = 0; i < tasks; i++) {
            final int start = i * numbersPerTask + 1;
            final int end = (i == tasks - 1) ? 100 : (i + 1) * numbersPerTask;

            executor.execute(() -> {
                try {
                    int partialSum = 0;
                    for (int j = start; j <= end; j++) {
                        partialSum += j;
                    }
                    totalSum.addAndGet(partialSum);
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await();
        executor.shutdown();
        return totalSum.get();
    }
}