手把手教你用Rust实现线程池（小白也能看懂的并发编程实战）

准备工作

在开始编码前，请确保你已安装 Rust 工具链。可以通过以下命令验证：

rustc --versioncargo --version

第1步：定义线程池结构

我们首先定义一个 ThreadPool 结构体，它包含一组工作线程和一个任务通道（channel）：

use std::sync::mpsc;use std::thread;pub struct ThreadPool {    workers: Vec<Worker>,    sender: mpsc::Sender<Job>,}type Job = Box<dyn FnOnce() + Send + 'static>;

这里我们使用 mpsc（多生产者单消费者）通道来传递任务。每个任务是一个实现了 FnOnce、Send 的闭包。

第2步：实现 Worker 结构

每个 Worker 拥有一个线程，并持续监听任务通道：

struct Worker {    id: usize,    thread: thread::JoinHandle<()>,}impl Worker {    fn new(id: usize, receiver: mpsc::Receiver<Job>) -> Worker {        let thread = thread::spawn(move || loop {            let job = receiver.recv().unwrap();            job();        });        Worker { id, thread }    }}

第3步：实现 ThreadPool 的构造函数

接下来，我们为 ThreadPool 实现 new 方法，用于初始化线程池：

impl ThreadPool {    pub fn new(size: usize) -> ThreadPool {        assert!(size > 0);        let (sender, receiver) = mpsc::channel();        let receiver = Arc::new(Mutex::new(receiver));        let mut workers = Vec::with_capacity(size);        for id in 0..size {            workers.push(Worker::new(id, Arc::clone(&receiver)));        }        ThreadPool { workers, sender }    }}

注意：我们需要引入 Arc 和 Mutex 来让多个线程安全地共享同一个接收端：

use std::sync::{Arc, Mutex};

第4步：添加 execute 方法

为了让用户能向线程池提交任务，我们实现 execute 方法：

impl ThreadPool {    // ... new 方法 ...    pub fn execute<F>(&self, f: F)    where        F: FnOnce() + Send + 'static,    {        let job = Box::new(f);        self.sender.send(job).unwrap();    }}

完整代码整合

将上述代码整合后，你就拥有了一个基本的 Rust多线程 线程池！以下是完整的模块代码：

use std::sync::{mpsc, Arc, Mutex};use std::thread;type Job = Box<dyn FnOnce() + Send + 'static>;pub struct ThreadPool {    workers: Vec<Worker>,    sender: mpsc::Sender<Job>,}impl ThreadPool {    pub fn new(size: usize) -> ThreadPool {        assert!(size > 0);        let (sender, receiver) = mpsc::channel();        let receiver = Arc::new(Mutex::new(receiver));        let mut workers = Vec::with_capacity(size);        for id in 0..size {            workers.push(Worker::new(id, Arc::clone(&receiver)));        }        ThreadPool { workers, sender }    }    pub fn execute<F>(&self, f: F)    where        F: FnOnce() + Send + 'static,    {        let job = Box::new(f);        self.sender.send(job).unwrap();    }}struct Worker {    id: usize,    thread: thread::JoinHandle<()>,}impl Worker {    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {        let thread = thread::spawn(move || loop {            let job = receiver.lock().unwrap().recv().unwrap();            job();        });        Worker { id, thread }    }}

使用示例

现在你可以这样使用你的线程池：

use std::time::Duration;fn main() {    let pool = ThreadPool::new(4);    for i in 0..8 {        pool.execute(move || {            println!("Task {} is running on thread {:?}", i, thread::current().id());            thread::sleep(Duration::from_millis(100));        });    }}

总结

通过本教程，你已经掌握了如何从零实现一个简单的 Rust线程池。这不仅加深了你对 并发编程 的理解，也为后续学习更复杂的异步模型（如 async/await）打下基础。记住，线程池实现 是高性能服务端开发的核心技能之一，值得深入掌握。

希望这篇教程对你有帮助！如果你是 Rust 新手，建议多动手实践，逐步优化这个线程池（例如添加优雅关闭、错误处理等功能）。