C++标准线程库：从基础到高级并发编程

1. C++标准线程库概览

C++11引入的标准线程库彻底改变了C++多线程编程的格局，让开发者不再依赖平台特定的API（如pthread或Windows线程API）。这套标准库提供了从线程创建到高级同步机制的全套工具，是现代C++并发编程的基石。

1.1 核心组件与头文件

标准线程库分布在多个头文件中，每个都针对特定的并发场景：

cpp复制#include <thread>          // 线程管理：std::thread, std::jthread(C++20)
#include <mutex>           // 互斥锁及相关RAII包装器
#include <condition_variable> // 线程间条件等待
#include <atomic>          // 原子操作与无锁编程
#include <future>          // 异步任务与结果获取
#include <stop_token>      // C++20引入的协作式停止机制
#include <semaphore>       // C++20信号量
#include <latch>           // C++20一次性屏障
#include <barrier>         // C++20可重用屏障

这套库主要解决三大类问题：

1. 线程生命周期管理：创建、执行和销毁线程
2. 线程安全与数据竞争：通过互斥锁和原子操作保证数据一致性
3. 线程间协作：条件变量、信号量等同步机制实现线程协调

实际开发中，90%的多线程场景都可以用<thread>、<mutex>和<atomic>这三个头文件解决。C++20新增的组件主要针对更复杂的同步需求。

1.2 线程库的演进历程

2. std::thread深度解析

2.1 线程构造的四种方式

std::thread的构造函数非常灵活，可以接受任何可调用对象：

普通函数

cpp复制void task(int param1, string param2) {
    // 线程执行逻辑
}

std::thread t(task, 42, "hello");

Lambda表达式

cpp复制std::thread t([](auto param) {
    // lambda体
}, some_value);

类成员函数

cpp复制class Worker {
public:
    void run(int iterations) {
        // 工作逻辑
    }
};

Worker w;
std::thread t(&Worker::run, &w, 1000);  // 注意对象指针作为第一个参数

函数对象（Functor）

cpp复制struct Task {
    void operator()(int n) const {
        // 重载调用运算符
    }
};

std::thread t(Task{}, 42);

2.2 参数传递的陷阱

线程参数传递有几个关键注意事项：

1. 默认是值传递：参数会被拷贝到线程的独立内存空间

   cpp复制int x = 10;
   std::thread t([](int val) { 
       val = 20;  // 不影响外部的x
   }, x);
   

2. 引用传递需要std::ref：

   cpp复制int x = 10;
   std::thread t([](int& val) {
       val = 20;  // 修改外部x
   }, std::ref(x));
   

3. 移动语义支持：

   cpp复制std::unique_ptr<int> ptr(new int(42));
   std::thread t([](std::unique_ptr<int> p) {
       // 接管所有权
   }, std::move(ptr));
   

2.3 线程生命周期管理

join()与detach()

• join()：阻塞当前线程直到目标线程完成

  cpp复制std::thread t(heavy_task);
  // ...其他工作...
  t.join();  // 等待线程结束
  

• detach()：让线程在后台独立运行

  cpp复制std::thread t(logging_task);
  t.detach();  // 主线程不再管理此线程
  

分离线程(detached)的最大风险是：如果主线程退出，所有分离线程会被立即终止，可能导致资源未释放。

joinable()检查

cpp复制if (t.joinable()) {
    // 只能join或detach一次
    t.join();  
}

2.4 线程标识与硬件并发

cpp复制// 获取当前线程ID
std::thread::id this_id = std::this_thread::get_id();

// 查询硬件支持的并发线程数
unsigned int n = std::thread::hardware_concurrency();

3. 线程安全与同步机制

3.1 mutex系列锁详解

基础mutex

cpp复制std::mutex mtx;
mtx.lock();
// 临界区
mtx.unlock();

RAII包装器

• lock_guard：最简单的RAII锁

  cpp复制{
      std::lock_guard<std::mutex> lock(mtx);
      // 自动加锁解锁
  }
  

• unique_lock：更灵活但稍重的锁

  cpp复制std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
  lock.lock();  // 可以手动控制加锁时机
  // ...
  lock.unlock();
  

特殊用途mutex

• recursive_mutex：允许同一线程重复加锁

  cpp复制std::recursive_mutex rmtx;
  rmtx.lock();
  rmtx.lock();  // OK
  rmtx.unlock();
  rmtx.unlock();
  

• shared_mutex：读写锁(C++17)

  cpp复制std::shared_mutex smtx;
  
  // 读锁（共享）
  {
      std::shared_lock lock(smtx);
      // 多个线程可同时读
  }
  
  // 写锁（独占）
  {
      std::unique_lock lock(smtx);
      // 只有一个线程可写
  }
  

3.2 条件变量实战

典型的生产者-消费者模式实现：

cpp复制std::mutex mtx;
std::condition_variable cv;
queue<int> msg_queue;
bool finished = false;

// 生产者
void producer() {
    for (int i = 0; i < 10; ++i) {
        {
            std::lock_guard lock(mtx);
            msg_queue.push(i);
        }
        cv.notify_one();
    }
    {
        std::lock_guard lock(mtx);
        finished = true;
    }
    cv.notify_all();
}

// 消费者
void consumer() {
    while (true) {
        std::unique_lock lock(mtx);
        cv.wait(lock, []{ 
            return !msg_queue.empty() || finished; 
        });
        
        if (finished && msg_queue.empty()) break;
        
        while (!msg_queue.empty()) {
            int msg = msg_queue.front();
            msg_queue.pop();
            lock.unlock();
            // 处理消息
            lock.lock();
        }
    }
}

条件变量的关键点：

1. wait()会自动释放锁并阻塞，被唤醒后重新获取锁
2. 总是使用while循环检查条件，防止虚假唤醒
3. notify_one()唤醒一个等待线程，notify_all()唤醒所有

3.3 原子操作精要

std::atomic提供无需锁的线程安全操作：

cpp复制std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

内存序选项：

• memory_order_relaxed：只保证原子性，不保证顺序
• memory_order_acquire/release：实现获取-释放语义
• memory_order_seq_cst：最严格的顺序一致性（默认）

原子操作适合简单的计数器、标志位，复杂数据结构仍需互斥锁。

4. C++20线程新特性

4.1 std::jthread的革命性改进

jthread解决了std::thread的两大痛点：

1. 自动join：析构时自动等待线程结束

   cpp复制{
       std::jthread t([]{
           std::this_thread::sleep_for(1s);
       });
   } // 自动join，不会崩溃
   

2. 协作式停止：通过stop_token优雅停止线程

   cpp复制std::jthread t([](std::stop_token st) {
       while (!st.stop_requested()) {
           // 工作...
       }
   });
   
   t.request_stop();  // 请求停止
   

4.2 同步原语三剑客

信号量(semaphore)

cpp复制std::counting_semaphore<10> sem(3);  // 初始3个许可

void worker() {
    sem.acquire();
    // 临界区（最多3个线程同时进入）
    sem.release();
}

门闩(latch)

cpp复制std::latch completion_latch(5);  // 需要5次count_down

void worker() {
    // 工作...
    completion_latch.count_down();
    completion_latch.wait();  // 等待所有完成
}

屏障(barrier)

cpp复制std::barrier sync_point(3);  // 3个参与线程

void computation() {
    // 阶段1
    sync_point.arrive_and_wait();
    
    // 阶段2
    sync_point.arrive_and_wait();
}

5. 高级技巧与最佳实践

5.1 线程局部存储

thread_local变量每个线程有独立副本：

cpp复制thread_local int thread_specific = 0;

void worker() {
    ++thread_specific;  // 不影响其他线程
}

典型应用：

• 随机数生成器
• 错误状态变量
• 递归算法中的临时存储

5.2 异步任务模式

std::async简化异步编程：

cpp复制auto future = std::async(std::launch::async, []{
    return compute_heavy_task();
});

// 做其他工作...
auto result = future.get();  // 获取结果

策略选项：

• std::launch::async：立即异步执行
• std::launch::deferred：延迟到get()时执行

5.3 死锁预防策略

1. 固定锁顺序：所有线程按相同顺序获取锁
2. 使用std::lock同时获取多个锁：

   cpp复制std::mutex mtx1, mtx2;
   
   std::lock(mtx1, mtx2);  // 原子性地获取两个锁
   std::lock_guard lock1(mtx1, std::adopt_lock);
   std::lock_guard lock2(mtx2, std::adopt_lock);
   

3. 避免嵌套锁：尽量减少锁的作用域
4. 使用RAII包装器：确保异常安全

6. 性能优化指南

6.1 锁粒度控制

• 细粒度锁：保护最小必要数据

  cpp复制class FineGrained {
      struct Bucket {
          std::mutex mtx;
          int data;
      };
      
      std::vector<Bucket> buckets;
  public:
      void update(int index, int value) {
          auto& bucket = buckets[index];
          std::lock_guard lock(bucket.mtx);
          bucket.data = value;
      }
  };
  

• 读写锁：读多写少场景

  cpp复制std::shared_mutex rw_lock;
  
  // 读操作
  {
      std::shared_lock lock(rw_lock);
      // 并发读取
  }
  
  // 写操作
  {
      std::unique_lock lock(rw_lock);
      // 独占写入
  }
  

6.2 无锁编程模式

原子操作实现无锁队列：

cpp复制template<typename T>
class LockFreeQueue {
    struct Node {
        T data;
        std::atomic<Node*> next;
    };
    
    std::atomic<Node*> head;
    std::atomic<Node*> tail;
    
public:
    void push(T value) {
        Node* new_node = new Node{std::move(value)};
        Node* old_tail = tail.exchange(new_node);
        old_tail->next = new_node;
    }
    
    bool pop(T& value) {
        Node* old_head = head.load();
        if (old_head == tail.load()) return false;
        
        head.store(old_head->next);
        value = std::move(old_head->data);
        delete old_head;
        return true;
    }
};

无锁编程复杂度高，通常只在性能关键路径使用。

6.3 线程池模式

避免频繁创建销毁线程：

cpp复制class ThreadPool {
    std::vector<std::jthread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable cv;
    bool stop = false;
    
public:
    ThreadPool(size_t threads) {
        for (size_t i = 0; i < threads; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock lock(queue_mutex);
                        cv.wait(lock, [this] {
                            return stop || !tasks.empty();
                        });
                        
                        if (stop && tasks.empty()) return;
                        
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }
    
    template<class F>
    void enqueue(F&& f) {
        {
            std::lock_guard lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        cv.notify_one();
    }
    
    ~ThreadPool() {
        {
            std::lock_guard lock(queue_mutex);
            stop = true;
        }
        cv.notify_all();
    }
};

7. 调试与问题排查

7.1 常见线程问题

1. 数据竞争：未同步的共享数据访问

   • 症状：随机崩溃、错误结果
   • 工具：ThreadSanitizer(TSan)

2. 死锁：循环等待锁

   • 症状：程序挂起
   • 工具：gdb的thread apply all bt命令

3. 活锁：线程持续改变状态但无法前进

   • 症状：CPU使用率高但无进展

7.2 调试技巧

• 打印线程ID辅助诊断：

  cpp复制std::cout << "[" << std::this_thread::get_id() << "] " 
            << "Debug message" << std::endl;
  

• 使用gdb检查线程状态：

  bash复制(gdb) info threads
  (gdb) thread 2  # 切换到线程2
  (gdb) bt         # 查看调用栈
  

• 启用ThreadSanitizer：

  bash复制g++ -fsanitize=thread -g program.cpp
  

8. 现代C++并发设计模式

8.1 消息传递模式

cpp复制template<typename Message>
class Actor {
    std::jthread worker;
    std::queue<Message> mailbox;
    std::mutex mtx;
    std::condition_variable cv;
    
    void run() {
        while (true) {
            Message msg;
            {
                std::unique_lock lock(mtx);
                cv.wait(lock, [this]{ return !mailbox.empty(); });
                msg = std::move(mailbox.front());
                mailbox.pop();
            }
            process(msg);
        }
    }
    
public:
    Actor() : worker(&Actor::run, this) {}
    
    void send(Message msg) {
        {
            std::lock_guard lock(mtx);
            mailbox.push(std::move(msg));
        }
        cv.notify_one();
    }
};

8.2 无锁工作窃取

cpp复制class WorkStealingQueue {
    std::deque<std::function<void()>> tasks;
    std::mutex mtx;
    
public:
    bool try_steal(std::function<void()>& task) {
        std::lock_guard lock(mtx, std::try_to_lock);
        if (!lock || tasks.empty()) return false;
        
        task = std::move(tasks.front());
        tasks.pop_front();
        return true;
    }
    
    bool push(std::function<void()> task) {
        std::lock_guard lock(mtx);
        tasks.push_back(std::move(task));
        return true;
    }
};

9. 跨平台注意事项

1. 线程优先级：标准库未规定优先级设置，需用平台API

   • Windows：SetThreadPriority
   • Linux：pthread_setschedparam

2. 处理器亲和性：同样需平台特定API

   • Windows：SetThreadAffinityMask
   • Linux：pthread_setaffinity_np

3. 栈大小：构造线程时可指定

   cpp复制std::thread t([]{
       // 工作...
   });
   
   // Windows
   SetThreadStackGuarantee(&t.native_handle(), 8*1024*1024);
   
   // Linux
   pthread_attr_t attr;
   pthread_attr_setstacksize(&attr, 8*1024*1024);
   

10. 实战：并行快速排序

cpp复制template<typename RandomIt>
void parallel_quick_sort(RandomIt first, RandomIt last) {
    if (last - first <= 10000) {
        std::sort(first, last);
        return;
    }
    
    auto pivot = *std::next(first, (last - first)/2);
    auto middle1 = std::partition(first, last, [pivot](const auto& elem) {
        return elem < pivot;
    });
    auto middle2 = std::partition(middle1, last, [pivot](const auto& elem) {
        return !(pivot < elem);
    });
    
    std::jthread left_thread([first, middle1] {
        parallel_quick_sort(first, middle1);
    });
    
    parallel_quick_sort(middle2, last);
}

关键优化点：

1. 小数组切换为串行排序
2. 使用jthread自动管理线程生命周期
3. 双分区减少相等元素的交换

11. 性能基准测试

测试环境：8核CPU，100万随机整数排序

结论：

1. 并行化带来显著加速
2. 线程数超过物理核心数后收益递减
3. 无锁版本性能略优但实现复杂

12. 未来演进方向

1. 执行器(Executors)：C++23引入的统一异步抽象

   cpp复制std::static_thread_pool pool(4);
   std::execution::execute(pool, []{
       // 在线程池执行
   });
   

2. 协程集成：与C++20协程结合

   cpp复制std::future<int> async_task() {
       auto result = co_await std::async([]{
           return compute_value();
       });
       co_return result;
   }
   

3. 硬件加速：与SIMD、GPU计算的协同

13. 终极决策指南

14. 专家级技巧

1. 伪共享(false sharing)优化：

   cpp复制struct alignas(64) CacheLineAligned {
       std::atomic<int> counter;
       // 填充剩余缓存行
       char padding[64 - sizeof(std::atomic<int>)];
   };
   

2. 定制内存序：

   cpp复制std::atomic<bool> ready{false};
   std::atomic<int> data{0};
   
   // 生产者
   data.store(42, std::memory_order_relaxed);
   ready.store(true, std::memory_order_release);
   
   // 消费者
   while (!ready.load(std::memory_order_acquire));
   int val = data.load(std::memory_order_relaxed);
   

3. 线程安全单例：

   cpp复制class Singleton {
   public:
       static Singleton& instance() {
           static Singleton inst;
           return inst;
       }
   private:
       Singleton() = default;
   };
   

15. 行业应用案例

1. 高频交易系统：

   • 使用无锁队列处理市场数据
   • 原子操作更新交易状态
   • 线程亲和性确保低延迟

2. 游戏引擎：

   • 任务并行化：物理、渲染、AI分线程
   • 双缓冲模式避免渲染卡顿
   • 使用屏障同步各子系统

3. Web服务器：

   • IO线程与计算线程分离
   • 线程池处理请求
   • 共享内存工作进程

16. 经典错误案例

1. 悬空引用：

   cpp复制void start_thread() {
       int local = 42;
       std::thread t([&local] {
           std::cout << local;  // 危险！local可能已销毁
       });
       t.detach();
   }
   

2. 锁顺序死锁：

   cpp复制// 线程1
   lock(mtx1);
   lock(mtx2);
   
   // 线程2
   lock(mtx2);
   lock(mtx1);
   

3. 过度订阅：

   cpp复制for (int i = 0; i < 1000; ++i) {
       std::thread t(work);  // 创建过多线程
       t.detach();
   }
   

17. 工具链支持

1. 编译器支持：

   • GCC：完全支持C++20线程
   • Clang：完全支持
   • MSVC：基本支持，部分C++20特性需最新版本

2. 调试工具：

   • Valgrind Helgrind：检测数据竞争
   • Intel Inspector：线程错误分析
   • Windows Performance Analyzer：线程活动可视化

3. 性能分析：

   • Linux perf：上下文切换统计
   • VTune：热点分析
   • Google CPU Profiler：调用图分析

18. 教育训练建议

1. 学习路径：

   1. 掌握std::thread基础
   2. 理解锁和条件变量
   3. 学习原子操作
   4. 研究无锁编程
   5. 探索高级模式

2. 训练项目：

   • 多线程日志系统
   • 并行图像处理
   • 模拟交易撮合引擎
   • 无锁哈希表实现

3. 代码审查重点：

   • 锁的作用域是否最小化
   • 是否存在潜在的竞态条件
   • 线程退出逻辑是否正确
   • 资源释放是否可靠

19. 历史教训与演进

1. 早期问题：

   • C++98缺乏标准线程支持
   • 各平台API差异大
   • 第三方库(如Boost.Thread)成为事实标准

2. C++11突破：

   • 统一线程模型
   • 内存模型正式定义
   • 原子操作支持

3. 现代改进：

   • C++20解决线程管理痛点
   • 引入更丰富的同步原语
   • 向更高级抽象发展(执行器、协程)

20. 终极代码模板

cpp复制#include <iostream>
#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <future>
#include <stop_token>  // C++20
#include <barrier>     // C++20
using namespace std::chrono_literals;

class ThreadSafeSystem {
    std::vector<std::jthread> workers;
    std::mutex mtx;
    std::condition_variable cv;
    std::atomic<bool> shutdown{false};
    std::barrier sync_point{2};  // 双线程屏障
    
public:
    void start() {
        workers.emplace_back(&ThreadSafeSystem::worker1, this);
        workers.emplace_back(&ThreadSafeSystem::worker2, this);
    }
    
    void stop() {
        shutdown.store(true);
        cv.notify_all();
    }
    
private:
    void worker1(std::stop_token st) {
        while (!st.stop_requested()) {
            std::unique_lock lock(mtx);
            cv.wait_for(lock, 100ms, [this, st] {
                return shutdown.load() || st.stop_requested();
            });
            
            if (shutdown || st.stop_requested()) break;
            
            // 工作阶段1
            sync_point.arrive_and_wait();
            
            // 工作阶段2
        }
    }
    
    void worker2(std::stop_token st) {
        while (!st.stop_requested()) {
            // 工作阶段1
            sync_point.arrive_and_wait();
            
            std::unique_lock lock(mtx);
            // 工作阶段2
        }
    }
};

int main() {
    ThreadSafeSystem sys;
    sys.start();
    
    std::this_thread::sleep_for(5s);
    sys.stop();
}

这个模板展示了：

1. 安全的线程启动/停止
2. 条件变量等待
3. 屏障同步
4. C++20停止令牌
5. RAII锁管理
6. 原子标志位

21. 性能调优检查表

1. [ ] 是否避免了不必要的锁？
2. [ ] 锁粒度是否足够细？
3. [ ] 是否有伪共享问题？
4. [ ] 线程数是否与硬件核心数匹配？
5. [ ] 是否使用了合适的同步原语？
6. [ ] 原子操作是否使用了最优内存序？
7. [ ] 是否有线程创建/销毁开销？
8. [ ] 任务负载是否均衡？

22. 安全编程准则

1. 资源管理：

   • 遵循RAII原则
   • 确保异常安全
   • 避免资源泄漏

2. 线程安全：

   • 默认认为共享数据不安全
   • 文档记录线程安全保证级别
   • 静态分析工具检查竞态条件

3. 防御性编程：

   • 检查joinable()状态
   • 处理异常传播
   • 设置线程栈大小上限

23. 扩展阅读推荐

1. 书籍：

   • 《C++ Concurrency in Action》(Anthony Williams)
   • 《The Art of Multiprocessor Programming》(Herlihy & Shavit)
   • 《Is Parallel Programming Hard?》(Paul McKenney)

2. 论文：

   • "A Tutorial Introduction to the ARM and POWER Relaxed Memory Models"
   • "The C++ Memory Model and Modern Hardware"

3. 在线资源：

   • CppReference并发章节
   • Herb Sutter的并发专栏
   • Intel线程开发指南

24. 社区最佳实践

1. 代码风格：

   • 为线程函数使用明确的前缀：thread_或worker_
   • 锁变量添加_mtx后缀
   • 原子变量添加_atomic后缀

2. 设计模式：

   • 优先使用任务并行而非数据并行
   • 避免暴露锁给外部
   • 使用不可变数据共享

3. 错误处理：

   • 线程函数捕获所有异常
   • 提供错误回调接口
   • 记录线程崩溃信息

25. 终极决策树

plaintext复制需要并行计算？
├─ 是 → 计算密集型？
│   ├─ 是 → 数据可分割？
│   │   ├─ 是 → 使用并行算法
│   │   └─ 否 → 使用任务并行
│   └─ 否 → IO密集型？
│       ├─ 是 → 使用异步IO
│       └─ 否 → 混合模式
└─ 否 → 需要响应性？
    ├─ 是 → 使用后台线程
    └─ 否 → 单线程即可

26. 行业趋势观察

1. 异构计算：

   • CPU与GPU/FPGA协同
   • 统一内存模型
   • SYCL/DPC++等抽象层

2. 持久内存：

   • 线程安全持久数据结构
   • 崩溃一致性保证
   • 新并发模式探索

3. 量子计算：

   • 量子线程概念
   • 量子-经典混合编程
   • 新的同步原语需求

27. 专家问答

Q: 何时选择线程而非协程？
A: 当需要利用多核并行性时用线程，处理大量IO等待时用协程。两者可结合使用。

Q: 无锁编程真的更快吗？
A: 在小争用情况下可能更快，但实现复杂且容易出错。应先证明锁是性能瓶颈再考虑无锁。

Q: 如何调试死锁？
A: 使用gdb的thread apply all bt查看所有线程栈，寻找循环等待模式。或使用Helgrind等工具。

28. 性能反模式

1. 锁粒度过大：

   cpp复制std::mutex global_mtx;  // 保护所有数据
   
   void process() {
       std::lock_guard lock(global_mtx);  // 序列化所有操作
       // ...
   }
   

2. 过度同步：

   cpp复制// 不必要的原子操作
   std::atomic<bool> initialized{false};
   void init() {
       if (!initialized) {
           std::lock_guard lock(mtx);
           if (!initialized) {
               // 初始化...
               initialized = true;
           }
       }
   }
   

3. 线程创建风暴：

   cpp复制void handle_requests() {
       while (true) {
           Request req = get_request();
           std::thread t(process, req);  // 每个请求创建线程
           t.detach();
       }
   }
   

29. 测试策略

1. 单元测试：

   • 模拟不同线程调度顺序
   • 注入延迟触发竞态条件
   • 验证线程安全接口

2. 压力测试：

   • 超出核心数的线程竞争
   • 长时间运行检测资源泄漏
   • 随机输入触发边界条件

3. 确定性测试：

   cpp复制void test_concurrent() {
       std::atomic<int> counter{0};
       std::vector<std::thread> threads;
       
       for (int i = 0; i < 10; ++i) {
           threads.emplace_back([&counter] {
               for (int j = 0; j < 1000; ++j) {
                   counter.fetch_add(1);
               }
           });
       }
       
       for (auto& t : threads) t.join();
       assert(counter == 10000);
   }
   

30. 资源清理模式

1. 线程局部清理：

   cpp复制thread_local std::vector<int> local_data;
   
   void worker() {
       try {
           // 使用local_data...
       } catch (...) {
           local_data.clear();  // 线程异常时清理
           throw;
       }
   }
   

2. 全局终止处理：

   cpp复制std::vector<std::thread> workers;
   
   void cleanup() {
       for (auto& t : workers) {
           if (t.joinable()) t.join();
       }
   }
   
   int main() {
       std::atexit(cleanup);
       // ...
   }
   

3. 资源回收线程：

   cpp复制class ResourceRecycler {
       std::jthread recycler;
       std::queue<Resource*> to_recycle;
       std::mutex mtx;
       std::condition_variable cv;
       
   public:
       ResourceRecycler() : recycler([this] {
           while (true) {
               Resource* res = nullptr;
               {
                   std::unique_lock lock(mtx);
                   cv.wait(lock, [this] { return !to_recycle.empty(); });
                   res = to_recycle.front();
                   to_recycle.pop();
               }
               delete res;
           }
       }) {}
       
       void recycle(Resource* res) {
           {
               std::lock_guard lock(mtx);
               to_recycle.push(res);
           }
           cv.notify_one();
       }
   };
   

31. 实时系统考量

1. 优先级继承：

   • 避免优先级反转
   • 使用std::mutex的native_handle()设置属性
   • 或直接使用平台特定API

2. 确定性调度：

   • 限制线程数量
   • 控制锁持有时间
   • 避免动态内存分配

3. 时间约束：

   cpp复制std::timed_mutex mtx;
   if (mtx.try_lock_for(10ms)) {
       // 关键操作
       mtx.unlock();
   } else {
       // 超时处理
   }
   

32. 容器与算法集成

1. 并行算法：

   cpp复制#include <execution>
   
   std::vector<int> data(1000000);
   std::sort(std::execution::par, data.begin(), data.end());
   

2. 线程安全容器：

   cpp复制template<typename T>
   class ConcurrentQueue {
       std::queue<T> queue;
       mutable std::mutex mtx;
       std::condition_variable cv;
       
   public:
       void push(T value) {
           {
               std::lock_guard lock(mtx);
               queue.push(std::move(value));
           }
           cv.notify_one();
       }
       
       bool try_pop(T& value) {
           std::lock_guard lock(mtx);
           if (queue.empty()) return false;
           value = std::move(queue.front());
           queue.pop();
           return true;
       }
   };
   

3. 并行变换：

   cpp复制std::vector<int> input(1000), output(1000);
   std::transform(std::execution::par, 
                 input.begin(), input.end(),
                 output.begin(),
                 [](int x) { return x * x; });
   

33. 异常安全模式

1. 异常传播：

   cpp复制std::promise<int> prom;
   std::thread t([&prom] {
       try {
           int result = compute();
           prom.set_value(result);
       } catch (...) {
           prom.set_exception(std::current_exception());
       }
   });
   
   auto fut