阶段 4 完整细化包（3 周详细课表 + 线程池代码框架 + 模拟面试题）

原创于 2026-06-26 08:19:19 发布 · 168 阅读

4 ·

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

GEO检测

收录于

C++

✅ 阶段 4 完整细化包（3 周详细课表 + 线程池代码框架 + 模拟面试题）

以下是针对阶段 4：多线程编程与并发 的完整细化内容。

一、3 周详细课表（Daily Schedule）

总时长：21 天（每天 2.5–4 小时）
每日结构：理论 40min + 编码 1.5–2h + 调试/总结 30min

Week 1：基础 + 同步原语（打牢根基）

Day 1：std::thread + join/detach + 简单并行累加
Day 2：std::async / future / promise + 异常传播
Day 3：std::mutex + std::lock_guard + unique_lock（银行账户练习）
Day 4：死锁演示与解决（std::lock() + 锁顺序）
Day 5：std::condition_variable + 生产者-消费者（单生产者单消费者）
Day 6：多生产者多消费者 + 虚假唤醒处理
Day 7：Week 1 复习 + 写总结文档 + Thread Sanitizer 使用

Week 2：线程安全容器 + 原子操作

Day 8：线程安全 Singleton（3 种实现对比）
Day 9：线程安全队列（std::deque + mutex + cv）
Day 10：读写锁（std::shared_mutex） + 线程安全 LRU Cache
Day 11：std::atomic 基础 + 无锁计数器 + memory_order 实验
Day 12：ABA 问题演示 + 带版本号的指针
Day 13：std::call_once + std::once_flag + 其他同步设施
Day 14：Week 2 代码重构 + 性能对比测试（单锁 vs 读写锁）

Week 3：线程池核心项目 + 综合实战

Day 15-17：线程池项目（分 3 天完成）
- Day 15：基础框架 + 任务队列 + 工作线程
- Day 16：std::future 支持返回值 + 优雅关闭
- Day 17：优先级任务 + 动态线程数（可选） + 压力测试
Day 18：并行计算实战（Monte Carlo 求 π 或并行文件搜索）
Day 19：并发 Bug 专项练习（故意制造 Data Race / Deadlock 并修复）
Day 20：线程池代码 review + 性能优化（减少锁竞争、批量任务等）
Day 21：阶段总结 + 面试题自测 + 项目文档整理（README）

二、具体项目代码框架 —— 高性能线程池（推荐重点实现）

文件结构建议：

ThreadPool/
├── ThreadPool.h
├── ThreadPool.cpp
├── TaskQueue.h
├── main.cpp
├── CMakeLists.txt

1. TaskQueue.h（线程安全任务队列）

#pragma once
#include <queue>
#include <functional>
#include <mutex>
#include <condition_variable>

class TaskQueue {
public:
    using Task = std::function<void()>;
    
    void push(Task task);
    Task pop();                    // 阻塞式取出
    bool try_pop(Task& task);      // 非阻塞
    void shutdown();
    bool is_shutdown() const;

private:
    std::queue<Task> queue_;
    mutable std::mutex mutex_;
    std::condition_variable cv_;
    bool shutdown_ = false;
};

2. ThreadPool.h（核心头文件）

#pragma once
#include "TaskQueue.h"
#include <vector>
#include <thread>
#include <future>
#include <atomic>

class ThreadPool {
public:
    explicit ThreadPool(size_t thread_count = std::thread::hardware_concurrency());
    ~ThreadPool();

    // 提交任务（支持返回值）
    template<typename F, typename... Args>
    auto submit(F&& f, Args&&... args) 
        -> std::future<std::invoke_result_t<F, Args...>>;

    void shutdown();
    size_t thread_count() const { return workers_.size(); }

private:
    void worker_thread();   // 工作线程主函数

    TaskQueue task_queue_;
    std::vector<std::thread> workers_;
    std::atomic<bool> stop_{false};
};

3. ThreadPool.cpp（核心实现框架）

#include "ThreadPool.h"

ThreadPool::ThreadPool(size_t thread_count) {
    for (size_t i = 0; i < thread_count; ++i) {
        workers_.emplace_back([this] { worker_thread(); });
    }
}

ThreadPool::~ThreadPool() {
    shutdown();
}

void ThreadPool::worker_thread() {
    while (true) {
        Task task = task_queue_.pop();
        if (task_queue_.is_shutdown() && !task) break;  // 退出信号
        if (task) task();
    }
}

template<typename F, typename... Args>
auto ThreadPool::submit(F&& f, Args&&... args) 
    -> std::future<std::invoke_result_t<F, Args...>> 
{
    using ReturnType = std::invoke_result_t<F, Args...>;
    auto task = std::make_shared<std::packaged_task<ReturnType()>>(
        std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    
    std::future<ReturnType> res = task->get_future();
    task_queue_.push([task]() { (*task)(); });
    return res;
}

void ThreadPool::shutdown() {
    // 实现优雅关闭逻辑
}