目录

书与作者
        本书相关
        前言
        封面图片介绍
        关于这本书
        路线图
        谁应该读这本书
        如何使用这本书
        本书概述
        代码公约和下载
        软件需求

第1章 你好，C++的并发世界        
        1.1 何谓并发        
                1.1.1 计算机系统中的并发        
                1.1.2 并发的途径        
        1.2 为什么使用并发？        
                1.2.1 为了分离关注点        
                1.2.2 为了性能        
                1.2.3 什么时候不使用并发        
        1.3 C++中使的并发和多线程        
                1.3.1 C++多线程历史        
                1.3.2 新标准支持并发
                1.3.3 C++线程库的效率
                1.3.4 平台相关的工具        
        1.4 开始入门        
                1.4.1 你好，并发世界        
        1.5 小结        

第2章 线程管理
        2.1 线程管理的基础
                2.1.1 启动线程        
                2.1.2 等待线程完成
                2.1.3 特殊情况下的等待
                2.1.4 后台运行线程        
        2.2 向线程函数传递参数        
        2.3 转移线程所有权        
        2.4 运行时决定线程数量        
        2.5 识别线程        
        2.6 总结        

第3章 线程间共享数据        
        3.1 共享数据带来的问题        
                3.1.1 条件竞争        
                3.1.2 避免恶性条件竞争        
        3.2 使用互斥量保护共享数据        
                3.2.1 C++中使用互斥量        
                3.2.2 精心组织代码来保护共享数据        
                3.2.3 发现接口内在的条件竞争        
                3.2.4 死锁：问题描述及解决方案        
                3.2.5 避免死锁的进阶指导        
                3.2.6 std::unique_lock——灵活的锁        
                3.2.7 不同域中互斥量所有权的传递        
                3.2.8 锁的粒度        
        3.3 保护共享数据的替代设施        
                3.3.1 保护共享数据的初始化过程        
                3.3.2 保护很少更新的数据结构        
                3.3.3 嵌套锁        
        3.4 总结     

   
第4章 同步并发操作        
        4.1 等待一个事件或其他条件        
                4.1.1 等待条件达成        
                4.1.2 使用条件变量构建线程安全队列        
        4.2 使用期望等待一次性事件        
                4.2.1 带返回值的后台任务        
                4.2.2 任务与期望        
                4.2.3 使用std::promises        
                4.2.4 为“期望”存储“异常”        
                4.2.5 多个线程的等待        
        4.3 限定等待时间        
                4.3.1 时钟        
                4.3.2 时延        
                4.3.3 时间点        
                4.3.4 具有超时功能的函数        
        4.4 使用同步操作简化代码        
                4.4.1 使用“期望”的函数化编程        
                4.4.2 使用消息传递的同步操作        
        4.5 总结        

第5章 C++内存模型和原子类型操作        
        5.1 内存模型基础        
                5.1.1 对象和内存位置        
                5.1.2 对象、内存位置和并发        
                5.1.3 修改顺序        
        5.2 C++中的原子操作和原子类型        
                5.2.1 标准原子类型        
                5.2.2 std::atomic_flag的相关操作        
                5.2.3 std::atomic的相关操作        
                5.2.4 std::atomic:指针运算        
                5.2.5 标准的原子整型的相关操作        
                5.2.6 std::atomic<>主要类的模板        
                5.2.7 原子操作的释放函数        
        5.3 同步操作和强制排序        
                5.3.1 同步发生        
                5.3.2 先行发生        
                5.3.3 原子操作的内存顺序        
                5.3.4 释放队列与同步        
                5.3.5 栅栏        
                5.3.6 原子操作对非原子的操作排序        
        5.4 总结  

     
第6章 基于锁的并发数据结构设计        
        6.1 为并发设计的意义何在？        
                6.1.1  数据结构并发设计的指导与建议(指南)        
        6.2 基于锁的并发数据结构        
                6.2.1 线程安全栈——使用锁        
                6.2.2 线程安全队列——使用锁和条件变量        
                6.2.3 线程安全队列——使用细粒度锁和条件变量        
        6.3 基于锁设计更加复杂的数据结构        
                6.3.1 编写一个使用锁的线程安全查询表        
                6.3.2 编写一个使用锁的线程安全链表        
        6.4 总结      

 
第7章 无锁并发数据结构设计        
        7.1 定义和意义        
                7.1.1 非阻塞数据结构        
                7.1.2 无锁数据结构        
                7.1.3 无等待数据结构        
        7.2 无锁数据结构的例子        
                7.2.1 写一个无锁的线程安全栈
                7.2.2 停止内存泄露：使用无锁数据结构管理内存
                7.2.3 检测使用风险指针(不可回收)的节点        
                7.2.4 检测使用引用计数的节点        
                7.2.5 应用于无锁栈上的内存模型        
                7.2.6 写一个无锁的线程安全队列
        7.3  对于设计无锁数据结构的指导建议        
                7.3.1 指导建议：使用 std::memory_order_seq_cst 的原 型
                7.3.2 指导建议：对无锁内存的回收策略        
                7.3.3 指导建议：小心ABA问题        
                7.3.4 指导建议：识别忙等待循环和帮助其他线程        
        7.4 总结

第8章 并发代码设计        
        8.1 线程间划分工作的技术        
                8.1.1 在线程处理前对数据进行划分        
                8.1.2 递归划分
                8.1.3 通过任务类型划分工作        
        8.2 影响并发代码性能的因素        
                8.2.1 有多少个处理器？
                8.2.2 数据争用与乒乓缓存        
                8.2.3 伪共享        
                8.2.4 如何让数据紧凑？        
                8.2.5 超额认购和频繁的任务切换        
        8.3 为多线程性能设计数据结构
                8.3.1 为复杂操作划分数组元素
                8.3.2 其他数据结构中的数据访问模式
        8.4 设计并发代码的注意事项
                8.4.1 并行算法中的异常安全
                8.4.2 可扩展性和Amdahl定律        
                8.4.3 使用多线程隐藏延迟        
                8.4.4 使用并发提高响应能力
        8.5 在实践中设计并发代码        
                8.5.1 并行实现：std::for_each        
                8.5.2 并行实现：std::find        
                8.5.3 并行实现：std::partial_sum        
        8.6 总结      

 
第9章 高级线程管理        
        9.1 线程池        
                9.1.1 最简单的线程池        
                9.1.2 等待提交到线程池中的任务        
                9.1.3 等待依赖任务        
                9.1.4 避免队列中的任务竞争        
                9.1.5 窃取任务        
        9.2 中断线程        
                9.2.1 启动和中断线程        
                9.2.2 检查线程是否中断        
                9.2.3 中断等待——条件变量        
                9.2.4 使用 std::condition_variable_any 中断等待
                9.2.5 中断其他阻塞调用
                9.2.6 处理中断        
                9.2.7 应用退出时中断后台任务        
        9.3 总结     

   
第10章 多线程程序的测试和调试
        10.1 与并发相关的错误类型        
                10.1.1 不必要阻塞
                10.1.2 条件竞争        
        10.2 定位并发错误的技术        
                10.2.1 代码审阅——发现潜在的错误
                10.2.2 通过测试定位并发相关的错误
                10.2.3 可测试性设计
                10.2.4 多线程测试技术        
                10.2.5 构建多线程测试代码        
                10.2.6 测试多线程代码性能        
        10.3 总结