随着多核处理器的广泛应用，多线程编程成为现代 C++ 开发的重要组成部分。本文将系统讲解 C++11 之后引入的多线程支持库，结合线程池的实现案例，帮助读者构建高效并发程序。

一、C++ 多线程基础

C++11 引入了 std::thread 类，可以直接创建新线程：

cpp复制编辑#include <iostream>#include <thread>void hello() {
    std::cout << \"Hello from thread!\" << std::endl;
}
int main() {
    std::thread t(hello); // 创建线程
    t.join();             // 主线程等待子线程结束
    return 0;
}

join()：主线程阻塞，等待子线程结束。
detach()：主线程与子线程分离，子线程独立运行，不能再 join()。

cpp复制编辑std::thread t(hello);
t.detach(); // 不可再 join

使用 detach() 时要确保线程函数内资源生命周期长于线程生命周期，防止访问已释放资源。

二、线程同步机制

多个线程访问共享资源时需加锁保护：

cpp复制编辑#include <mutex>std::mutex mtx;void safe_print(int id) {    std::lock_guard<std::mutex> lock(mtx);
    std::cout << \"Thread \" << id << \" safely printing\" << std::endl;
}

死锁常见于多个线程交叉持有多个锁。常见避免策略：

避免嵌套锁。
使用 std::lock() + std::lock_guard。
使用层次锁（高级技巧）。

三、C++11 条件变量与原子变量

cpp复制编辑std::mutex mtx;
std::condition_variable cv;bool ready = false;void worker() {    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; });
    std::cout << \"Worker running\" << std::endl;
}

cpp复制编辑#include <atomic>std::atomic<int> counter(0);void increment() {
    counter++;
}

四、线程池设计与实现

线程池是一种预先创建多个线程，复用这些线程处理多个任务的并发模型。可避免频繁创建销毁线程的开销。

一个任务队列（如 std::queue）。
一个线程数组。
条件变量用于任务唤醒。
互斥锁保护共享资源。

cpp复制编辑#include <vector>#include <queue>#include <thread>#include <mutex>#include <condition_variable>#include <functional>#include <future>#include <iostream>#include <atomic>class ThreadPool {public:    ThreadPool(size_t n) : stop(false) {        for (size_t i = 0; i < n; ++i) {
            workers.emplace_back([this] {                while (true) {
                    std::function<void()> task;
                    
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });                        if (stop && tasks.empty()) return;
                        task = std::move(tasks.front());
                        tasks.pop();
                    }                    task();
                }
            });
        }
    }    template<class F, class... Args>    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::invoke_result<F, Args...>::type> 
    {        using return_type = typename std::invoke_result<F, Args...>::type;        auto task = std::make_shared<std::packaged_task<return_type()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
        std::future<return_type> res = task->get_future();
        
        {            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace([task]() { (*task)(); });
        }
        
        condition.notify_one();        return res;
    }
    ~ThreadPool() {
        {            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();        for (std::thread &worker : workers) {
            worker.join();
        }
    }private:
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;    bool stop;
};

cpp复制编辑int main() {    ThreadPool pool(4);
    std::vector<std::future<int>> results;    for (int i = 0; i < 8; ++i) {
        results.emplace_back(
            pool.enqueue([i] {
                std::this_thread::sleep_for(std::chrono::milliseconds(100));                return i * i;
            })
        );
    }    for (auto& r : results) {
        std::cout << r.get() << \" \";
    }
    return 0;
}

复制编辑0 1 4 9 16 25 36 49

五、线程池进阶优化方向

可以监测任务量自动调整线程数量，实现弹性线程池。

任务队列使用 std::priority_queue，支持高优先级任务先执行。

记录线程空闲时间，长时间空闲可回收资源。

总结

本文从 C++ 多线程基础出发，介绍了线程创建、同步机制、原子变量、条件变量等关键技术，并实战构建了一个简洁实用的线程池类，具备任务提交、异步结果获取、资源安全释放等完整特性。

线程池是服务器开发、高性能任务调度、并发任务管理中不可或缺的利器。通过本文的讲解，你可以在项目中灵活应用并扩展更复杂的线程池模型，提升系统的并发处理能力。

ITPub博客

C++ 多线程编程基础与线程池实战

一、C++ 多线程基础

二、线程同步机制

三、C++11 条件变量与原子变量

四、线程池设计与实现

五、线程池进阶优化方向

总结

ITPub博客

C++ 多线程编程基础与线程池实战

一、C++ 多线程基础

1.1 std::thread 的使用

1.2 线程等待与分离

二、线程同步机制

2.1 std::mutex 互斥锁

2.2 死锁与避免策略

三、C++11 条件变量与原子变量

3.1 条件变量 std::condition_variable

3.2 原子操作 std::atomic

四、线程池设计与实现

4.1 基本结构

4.2 简易线程池实现

4.3 使用线程池

五、线程池进阶优化方向

5.1 动态扩容线程数

5.2 支持任务优先级

5.3 支持线程空闲回收

总结

最新文章

1.1 `std::thread` 的使用

2.1 `std::mutex` 互斥锁

3.1 条件变量 `std::condition_variable`

3.2 原子操作 `std::atomic`