线程池的介绍及简单实现

封面图 • 2026-01-08 • Java

线程池（Thread Pool）是一种**多线程编程中的资源管理技术**，它预先创建一组线程，并将这些线程放入一个“池”中，等待任务的分配。当有新的任务需要执行时，线程池会从池中取出一个空闲线程来执行该任务，任务完成后线程回到池中等待下一次任务。

---

## 一、线程池的优点

1. **提高性能**：避免频繁创建和销毁线程的开销。
2. **资源控制**：限制最大并发线程数，防止系统资源被耗尽。
3. **任务调度更灵活**：可以对任务进行排队、优先级处理等。
4. **提升响应速度**：线程复用，减少等待时间。

---

## 二、线程池的核心组件

通常包括以下几部分：

- **任务队列（Task Queue）**：存放待执行的任务。
- **工作线程（Worker Threads）**：从任务队列中获取任务并执行。
- **线程池管理器（Pool Manager）**：负责线程的创建、回收、任务分配等。

---

## 三、线程池的工作流程

1. 线程池初始化若干个工作线程，它们处于等待状态。
2. 客户端提交任务到线程池。
3. 线程池将任务放入任务队列。
4. 工作线程从任务队列中取出任务并执行。
5. 任务执行完成后，线程回到线程池继续等待新任务。

---

## 四、Java 中的线程池实现（使用 `java.util.concurrent` 包）

Java 提供了强大的线程池支持，核心类是 `ThreadPoolExecutor`。

### 示例代码：

```java
import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池，核心线程数为 2，最大线程数为 4，任务队列容量为 5
        ExecutorService executor = new ThreadPoolExecutor(
                2,                  // 核心线程数
                4,                  // 最大线程数
                60L,                // 空闲线程存活时间
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(5), // 任务队列
                new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );

for (int i = 0; i < 10; i++) {
            int taskId = i;
            executor.execute(() -> {
                System.out.println("Task " + taskId + " is running on thread: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

executor.shutdown(); // 关闭线程池
    }
}
```

### 输出示例：
```
Task 0 is running on thread: pool-1-thread-1
Task 1 is running on thread: pool-1-thread-2
Task 2 is running on thread: pool-1-thread-1
Task 3 is running on thread: pool-1-thread-2
...
```

---

## 五、简单的线程池实现（手动实现）

下面是一个非常基础的线程池实现，用于理解其原理。

### 示例代码（简单线程池）：

```java
import java.util.*;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

class Task implements Runnable {
    private String name;

public Task(String name) {
        this.name = name;
    }

@Override
    public void run() {
        System.out.println("Executing task: " + name + " by thread: " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SimpleThreadPool {
    private BlockingQueue<Runnable> taskQueue;
    private List<Worker> workers;
    private boolean isRunning = true;

public SimpleThreadPool(int poolSize) {
        taskQueue = new LinkedBlockingQueue<>();
        workers = new ArrayList<>();

for (int i = 0; i < poolSize; i++) {
            Worker worker = new Worker();
            workers.add(worker);
            worker.start();
        }
    }

public void submit(Runnable task) {
        try {
            taskQueue.put(task);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

public void shutdown() {
        isRunning = false;
        for (Worker worker : workers) {
            worker.interrupt();
        }
    }

private class Worker extends Thread {
        @Override
        public void run() {
            while (isRunning || !taskQueue.isEmpty()) {
                try {
                    Runnable task = taskQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    if (!isRunning) break;
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        SimpleThreadPool pool = new SimpleThreadPool(2);

for (int i = 0; i < 10; i++) {
            pool.submit(new Task("Task-" + i));
        }

pool.shutdown();
    }
}
```

---

## 六、总结

| 项目 | 内容 |
|------|------|
| 线程池 | 复用线程，提高性能，控制资源 |
| Java 实现 | 使用 `ThreadPoolExecutor` 或 `Executors` 工具类 |
| 手动实现 | 通过线程 + 队列 + 循环机制实现 |

---

如果你希望我提供其他语言（如 C++、Python）的线程池实现，也可以告诉我！