Java并发基础中任务拆分利器（五）：Executors.newFixedThreadPool

最新推荐文章于 2026-06-10 19:24:52 发布

原创最新推荐文章于 2026-06-10 19:24:52 发布 · 944 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#经验分享 #后端 #java

概述

Executors.newFixedThreadPool 是 Java 提供的一个工厂方法，用于创建一个固定大小的线程池。该线程池中的线程数量是固定的，适用于需要拆分任务并进行结果合并的场景。通过使用固定大小的线程池，可以有效地管理和复用线程资源，提高系统的性能和响应速度。

主要特点

固定大小：线程池中的线程数量是固定的。
线程复用：线程池中的线程会被复用，减少线程创建和销毁的开销。
阻塞队列：使用无界队列来存储待执行的任务，当线程池中的所有线程都在忙碌时，新提交的任务会进入队列等待。

应用场景

服务器端处理大量请求：例如Web服务器处理HTTP请求。
批处理任务：需要处理大量相似的任务，且任务之间没有依赖关系。
资源受限的环境：系统资源有限，需要控制线程的数量以避免资源耗尽。
任务拆分合并结果：将一个大型任务拆分成多个小任务，并行处理这些小任务，在所有小任务完成后，将它们的结果合并成最终结果。

实现原理

Executors.newFixedThreadPool方法返回的是一个ThreadPoolExecutor实例，其构造函数如下：

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

关键方法

execute(Runnable command)：提交一个新的任务到线程池中。
shutdown()：平滑地关闭线程池，不再接受新的任务，但会等待已提交的任务完成。
shutdownNow()：立即关闭线程池，尝试停止所有正在执行的任务并清空任务队列。

源码解析

ThreadPoolExecutor的构造函数参数如下：

corePoolSize 和 maximumPoolSize：都设置为nThreads，表示线程池的核心线程数和最大线程数相同。
keepAliveTime 和 unit：设置为0，表示多余的线程不会被保留。
workQueue：使用LinkedBlockingQueue作为任务队列，这是一个无界队列。

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

应用案例

以下是一个简单的示例代码，展示了如何使用Executors.newFixedThreadPool来进行任务的拆分和合并。具体来说，我们将一个大任务拆分成多个小任务并行处理，然后将结果合并成最终的结果。

假设我们有一个大型的数据集，需要对其进行一些计算（例如求和）。为了提高处理速度，我们可以将数据集拆分成多个小块，每个小块由一个线程处理，最后将所有小块的结果合并成最终结果。

示例代码

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TaskSplitAndMergeExample {

    public static void main(String[] args) {
        // 创建一个固定大小为4的线程池
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // 假设有一个大型数据集
        int[] largeDataSet = new int[1000000];
        for (int i = 0; i < largeDataSet.length; i++) {
            largeDataSet[i] = i + 1;
        }

        // 将数据集拆分成多个小块并提交任务到线程池
        int chunkSize = 250000;
        List<SumTask> tasks = new ArrayList<>();
        for (int i = 0; i < largeDataSet.length; i += chunkSize) {
            int end = Math.min(i + chunkSize, largeDataSet.length);
            tasks.add(new SumTask(largeDataSet, i, end));
        }

        // 提交任务并关闭线程池
        try {
            for (SumTask task : tasks) {
                executor.execute(task);
            }
        } catch (Exception e) {
            System.err.println("任务提交失败: " + e.getMessage());
            executor.shutdownNow(); // 立即关闭线程池
            return; // 退出程序
        }

        executor.shutdown();
        try {
            // 等待所有任务完成
            if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
                System.err.println("一些任务在超时期间内没有完成。");
            }
        } catch (InterruptedException e) {
            System.err.println("等待任务完成被中断: " + e.getMessage());
            executor.shutdownNow(); // 立即关闭线程池
        }

        // 合并结果
        long totalSum = tasks.stream().mapToLong(SumTask::getPartialSum).sum();

        // 输出最终结果
        System.out.println("Total sum: " + totalSum);
    }

    static class SumTask implements Runnable {
        private final int[] data;
        private final int start;
        private final int end;
        private long partialSum;

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

        @Override
        public void run() {
            for (int i = start; i < end; i++) {
                partialSum += data[i];
            }
        }

        public long getPartialSum() {
            return partialSum;
        }
    }
}