java实现线程池（附带源码）

最新推荐文章于 2025-11-02 17:43:07 发布

原创最新推荐文章于 2025-11-02 17:43:07 发布 · 1.1k 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java 实战项目专栏收录该内容

1306 篇文章

订阅专栏

Java 实现线程池详解

一、项目概述

在并发编程中，线程池是一种非常重要的设计模式。它通过事先创建和维护一定数量的工作线程来处理任务，避免了频繁创建和销毁线程带来的资源开销，从而提高系统性能和响应速度。Java 标准库中的 java.util.concurrent 包已经提供了线程池相关的工具（例如：ThreadPoolExecutor），但深入理解线程池的设计与实现原理对于开发高性能并发应用至关重要。

本项目旨在从零开始实现一个简易的线程池，主要涵盖以下内容：

线程池的基本概念与工作原理
为什么以及在什么场景下需要线程池
自定义线程池的设计思路：包括工作线程（Worker）、任务队列、线程管理、任务提交与调度等
详细代码实现：包含自定义阻塞队列（BlockingQueue）和线程池的实现，所有代码整合在一起，并附有非常详细的注释
代码解读：针对每个关键方法和设计思想进行详细说明
项目总结与未来改进方向

通过本文，读者不仅能够学到如何利用 Java 实现一个简易线程池，还能深入理解线程池的内部机制，为构建高性能系统打下坚实基础。

二、线程池简介

1. 什么是线程池？

线程池是一种线程复用机制，通过预先创建一组线程来执行异步任务。任务提交到线程池后，会被存储在任务队列中，等待线程池中的空闲线程来执行。线程池的主要目的是避免在高并发场景下频繁创建和销毁线程，从而降低资源消耗、减少系统开销和提高响应速度。

2. 为什么使用线程池？

降低资源开销
线程创建和销毁都需要消耗系统资源，尤其在高并发情况下，频繁创建线程可能导致系统资源枯竭。而线程池通过线程复用，可以有效降低这种开销。
提高响应速度
预先创建的线程可以快速响应任务请求，避免了动态创建线程的延时。
便于管理
线程池集中管理工作线程，便于进行状态监控、调度和扩展，同时可以根据任务负载动态调整线程数量。

3. 线程池的应用场景

Web 服务器与应用服务器
线程池常用于处理 HTTP 请求，确保高并发请求下服务器能够快速响应。
异步任务处理
后台任务、日志处理、定时任务等场景中，线程池能够平滑处理大量异步任务。
高并发计算
在大数据、科学计算等场景中，通过线程池实现多任务并行处理，提高整体计算效率。

三、Java 实现线程池的基本原理

在实现线程池时，我们通常需要关注以下几个核心组件：

1. 任务队列（Task Queue）

任务队列用于存储待处理的任务。线程池中所有工作线程会从该队列中获取任务进行执行。为了保证线程安全与任务调度的正确性，任务队列一般需要实现阻塞队列的特性——当队列为空时，取任务的线程需要等待；当队列已满时，提交任务的线程需要阻塞或拒绝任务。

2. 工作线程（Worker Threads）

工作线程负责不断从任务队列中获取任务并执行。每个工作线程通常是一个无限循环，执行完当前任务后继续等待新的任务，直到线程池关闭或线程超时退出。

3. 线程池管理（Thread Pool Manager）

线程池管理器负责创建、维护和调度工作线程。常见的线程池设计中会定义以下参数：

核心线程数（corePoolSize）：保持运行的最低线程数。
最大线程数（maximumPoolSize）：允许创建的最大线程数。
空闲线程存活时间（keepAliveTime）：超过核心线程数的线程如果长时间没有任务就会被回收。
任务队列容量：任务队列的最大存储任务数。

线程池在任务提交时首先判断是否有空闲线程可用，如果没有则尝试创建新的线程；若已达到最大线程数，则任务提交可能会被阻塞或拒绝。

四、设计思路

在本项目中，我们设计了一个简易线程池，主要组件包括：

自定义阻塞队列（BlockingQueue）
我们使用自定义的阻塞队列来保存待执行任务，采用 wait 和 notifyAll 实现阻塞和唤醒机制，确保线程安全。
线程池类（MyThreadPool）
线程池类中维护了任务队列、工作线程集合以及线程池相关参数（核心线程数、最大线程数、空闲存活时间等）。任务提交时，线程池会判断当前线程数量和任务队列状态，决定是直接分配给新线程还是放入任务队列等待。
工作线程（Worker 内部类）
每个工作线程会不断从任务队列中获取任务执行。工作线程内部设计为一个无限循环，在任务执行结束后重新尝试获取下一个任务；同时还考虑了线程池关闭的场景。
线程池关闭机制
提供了 shutdown 方法，用于平滑关闭线程池。当线程池关闭后，不再接收新任务，且工作线程在完成当前任务后退出。

下图展示了线程池的整体设计架构：

┌───────────────────────────────┐
│ MyThreadPool │
│ ─────────────────────────── │
│ - BlockingQueue<Runnable> taskQueue │
│ - List<Worker> workers │
│ - corePoolSize │
│ - maximumPoolSize │
│ - keepAliveTime │
│ - isShutdown │
│ + execute(Runnable task) │
│ + shutdown() │
└───────────────┬───────────────┘
│
▼
┌─────────────────┐
│ Worker │
│ (extends Thread)│
│ run() 方法 │
└─────────────────┘

五、详细代码实现及注释

下面给出整合后的完整代码。代码分为两大部分：自定义阻塞队列（BlockingQueue）和线程池实现（MyThreadPool），其中包含了详细的注释，便于读者理解每个方法的功能和设计思路。

5.1 自定义阻塞队列实现

import java.util.LinkedList;
import java.util.Queue;

/**
 * BlockingQueue 类实现了一个简单的阻塞队列。
 * 该队列采用内部锁和 wait/notifyAll 机制，
 * 保证在队列为空时调用 take() 方法的线程会阻塞，
 * 在队列满时调用 put() 方法的线程也会阻塞，直到有空间。
 *
 * @param <T> 队列中存储的数据类型
 */
public class BlockingQueue<T> {
    // 内部队列，使用 LinkedList 存储数据
    private final Queue<T> queue = new LinkedList<>();
    // 队列的最大容量
    private final int capacity;

    /**
     * 构造方法，根据指定容量初始化队列。
     *
     * @param capacity 队列的最大容量
     * @throws IllegalArgumentException 如果容量小于等于 0
     */
    public BlockingQueue(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException("容量必须大于 0");
        }
        this.capacity = capacity;
    }

    /**
     * put 方法用于向队列中添加数据。
     * 如果队列已满，则当前线程会被阻塞，直到有空间。
     *
     * @param item 要添加的数据
     * @throws InterruptedException 如果线程等待期间被中断
     */
    public synchronized void put(T item) throws InterruptedException {
        while (queue.size() == capacity) {
            // 队列已满，等待空位出现
            wait();
        }
        queue.offer(item);
        // 添加元素后唤醒等待的线程
        notifyAll();
    }

    /**
     * take 方法用于从队列中获取数据。
     * 如果队列为空，则当前线程会被阻塞，直到有数据可取。
     *
     * @return 队列头部的数据
     * @throws InterruptedException 如果线程等待期间被中断
     */
    public synchronized T take() throws InterruptedException {
        while (queue.isEmpty()) {
            // 队列为空，等待新数据到来
            wait();
        }
        T item = queue.poll();
        // 移除数据后唤醒等待 put 操作的线程
        notifyAll();
        return item;
    }

    /**
     * size 方法返回当前队列中的元素个数。
     *
     * @return 队列大小
     */
    public synchronized int size() {
        return queue.size();
    }

    /**
     * isEmpty 方法用于判断队列是否为空。
     *
     * @return 如果队列为空则返回 true，否则返回 false
     */
    public synchronized boolean isEmpty() {
        return queue.isEmpty();
    }
}

5.2 自定义线程池实现

import java.util.ArrayList;
import java.util.List;

/**
 * MyThreadPool 类实现了一个简单的线程池。
 * 线程池内部维护一个阻塞队列用于存储任务，
 * 以及一组工作线程用于不断从队列中获取任务并执行。
 *
 * 核心参数包括：
 * - corePoolSize：线程池中始终保持的核心线程数
 * - maximumPoolSize：线程池允许的最大线程数
 * - keepAliveTime：非核心线程在空闲状态下存活的最长时间（单位：毫秒）
 *
 * 线程池支持任务提交（execute）和优雅关闭（shutdown）。
 */
public class MyThreadPool {
    // 核心线程数
    private final int corePoolSize;
    // 最大线程数
    private final int maximumPoolSize;
    // 非核心线程的存活时间（毫秒）
    private final long keepAliveTime;
    // 任务队列
    private final BlockingQueue<Runnable> taskQueue;
    // 保存所有工作线程
    private final List<Worker> workers;
    // 线程池是否已经关闭的标志
    private volatile boolean isShutdown = false;
    // 用于同步控制的锁对象
    private final Object lock = new Object();

    /**
     * 构造方法，根据指定参数初始化线程池。
     *
     * @param corePoolSize   核心线程数
     * @param maximumPoolSize 最大线程数
     * @param keepAliveTime  非核心线程的存活时间（毫秒）
     * @param queueCapacity  任务队列的容量
     */
    public MyThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, int queueCapacity) {
        if (corePoolSize <= 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize) {
            throw new IllegalArgumentException("线程池参数不合法");
        }
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.keepAliveTime = keepAliveTime;
        this.taskQueue = new BlockingQueue<>(queueCapacity);
        this.workers = new ArrayList<>();
    }

    /**
     * execute 方法用于提交任务到线程池。
     * 如果当前工作线程数小于核心线程数，则直接创建新的工作线程来处理任务；
     * 否则将任务放入任务队列中等待执行，如果任务队列中有积压任务且线程数未达到最大值，
     * 则可能创建非核心线程来协同处理任务。
     *
     * @param task 要执行的任务（实现 Runnable 接口）
     * @throws InterruptedException 如果线程在等待过程中被中断
     */
    public void execute(Runnable task) throws InterruptedException {
        if (task == null) {
            throw new IllegalArgumentException("任务不能为空");
        }
        synchronized (lock) {
            if (isShutdown) {
                throw new IllegalStateException("线程池已经关闭，不能提交新任务");
            }
            // 如果当前工作线程数不足核心线程数，则直接启动一个新线程处理任务
            if (workers.size() < corePoolSize) {
                Worker worker = new Worker(task);
                workers.add(worker);
                worker.start();
            } else {
                // 尝试将任务放入任务队列（此处 put 方法会阻塞直到有空位）
                taskQueue.put(task);
                // 如果任务队列中有任务等待且工作线程数尚未达到最大线程数，则扩充线程数量
                if (taskQueue.size() > 0 && workers.size() < maximumPoolSize) {
                    Worker worker = new Worker(null);
                    workers.add(worker);
                    worker.start();
                }
            }
        }
    }

    /**
     * shutdown 方法用于优雅地关闭线程池。
     * 调用该方法后，线程池不再接受新任务，并会等待已提交任务执行完毕后停止所有线程。
     */
    public void shutdown() {
        synchronized (lock) {
            isShutdown = true;
            // 中断所有工作线程
            for (Worker worker : workers) {
                worker.interrupt();
            }
        }
    }

    /**
     * Worker 内部类继承自 Thread，代表线程池中的工作线程。
     * 每个 Worker 在启动后会先执行自身初始化时分配的首个任务，
     * 然后进入一个循环，不断从任务队列中获取任务并执行。
     */
    private class Worker extends Thread {
        // 首个任务，由线程池在创建 Worker 时传入
        private Runnable firstTask;

        /**
         * Worker 构造方法，根据传入的首个任务初始化工作线程。
         *
         * @param firstTask 首个任务，可以为 null，表示先从队列中取任务
         */
        public Worker(Runnable firstTask) {
            this.firstTask = firstTask;
        }

        @Override
        public void run() {
            Runnable task = firstTask;
            // 清空首个任务引用，避免重复执行
            firstTask = null;
            try {
                // 如果任务不为 null 或者从任务队列中获取任务不为空，则执行任务
                while (task != null || (task = taskQueue.take()) != null) {
                    try {
                        task.run();
                    } catch (RuntimeException e) {
                        // 捕获任务执行过程中出现的异常，避免线程因异常退出
                        e.printStackTrace();
                    }
                    task = null;
                    // 非核心线程如果空闲时间超过 keepAliveTime 则退出（简单实现，不做精细计时）
                    if (workers.size() > corePoolSize && isShutdown) {
                        break;
                    }
                }
            } catch (InterruptedException e) {
                // 工作线程被中断后退出
                Thread.currentThread().interrupt();
            } finally {
                // 线程退出前，从工作线程集合中移除自己
                synchronized (lock) {
                    workers.remove(this);
                }
            }
        }
    }
}

六、代码解读

1. BlockingQueue 类

内部数据结构
使用 LinkedList 作为底层存储容器，并通过容量限制保证队列不会无限增长。
put(T item) 方法
当队列已满时，调用线程会被阻塞（利用 wait()），直到有其他线程调用 take() 方法取走任务并唤醒等待线程（调用 notifyAll()）。
take() 方法
当队列为空时，调用线程会被阻塞，等待新任务到来；取出数据后同样调用 notifyAll() 唤醒等待 put() 的线程。

2. MyThreadPool 类

构造方法
根据传入参数初始化线程池，设置核心线程数、最大线程数、任务队列容量等，初始化工作线程集合。
execute(Runnable task) 方法
任务提交时，首先检查线程池是否关闭，然后：
- 如果当前工作线程数量小于核心线程数，直接创建一个新的 Worker 并启动，执行任务；
- 否则，将任务放入阻塞队列中；如果队列中任务较多且线程数未达到最大值，可能创建非核心线程来辅助执行任务。
shutdown() 方法
标记线程池已关闭，并中断所有工作线程，从而使得工作线程在完成当前任务后退出循环。

3. Worker 内部类

工作流程
Worker 在启动后首先执行构造时传入的首个任务（如果有），然后不断调用 taskQueue.take() 从队列中获取任务并执行，直到队列为空或线程池关闭。
异常处理
在任务执行过程中捕获所有运行时异常，防止因任务异常导致线程退出。
退出机制
当线程池关闭或者当前线程属于非核心线程且处于空闲状态时，Worker 会退出循环，并在 finally 块中从线程池中移除自身。

七、项目总结与展望

1. 项目收获

通过本项目，你将学到：

线程池基本原理
深入理解线程池如何利用任务队列和工作线程实现任务复用和异步执行。
自定义阻塞队列的实现
掌握如何利用 wait/notifyAll 机制实现一个线程安全的阻塞队列，这也是实现生产者—消费者模型的核心技术之一。
线程管理与调度策略
了解如何根据任务负载动态调整线程池中线程的数量，以及如何平滑关闭线程池，确保任务完整执行。

2. 线程池的优势与局限

优势

高效复用线程
避免了频繁创建销毁线程的开销，在高并发场景下能大幅提升性能。
任务调度与管理集中化
线程池能统一管理任务调度、线程状态和系统资源，便于维护和监控。
灵活的扩展性
通过设置核心线程数、最大线程数和任务队列容量，可以根据业务需求调整性能和资源占用。

局限

实现复杂度较高
自定义线程池需要处理线程安全、任务队列阻塞、线程回收等诸多问题，代码实现相对复杂。
资源预估问题
固定容量的任务队列和线程数需要在设计时预估好，若预估不足可能导致任务积压或系统资源浪费。

3. 未来改进方向

动态扩容
实现动态调整任务队列容量和线程数，针对不同负载情况自动扩容或收缩，提高系统适应性。
无锁设计
研究使用无锁算法和原子操作实现任务队列，进一步降低线程同步开销，提高并发性能。
任务拒绝策略
当任务队列满时，提供更加灵活的任务拒绝与回退策略，例如抛出异常、调用者运行策略、静默丢弃等。
监控与调试工具
为线程池增加监控接口，实时获取线程池中工作线程数量、任务队列长度、执行任务统计等信息，便于生产环境下的调优和故障排查。

八、总结

本文详细介绍了如何用 Java 从零实现一个简易线程池。文章首先阐述了线程池的基本概念、工作原理以及在高并发系统中的重要作用；接着介绍了线程池设计的核心组件——任务队列、工作线程以及线程管理策略；然后提供了包含自定义阻塞队列和线程池完整实现的代码示例，并附有详细注释和代码解读；最后，对项目进行总结并探讨了未来改进的方向。

通过本文，你可以了解到：