downdemo / cpp-concurrency-in-action-2ed

C++11/14/17/20 multithreading, involving operating system principles and concurrent programming technology.

• C++11 引入了 Boost 线程库作为标准线程库，作者 Anthony Williams 为介绍其特性，于 2012 年出版了 C++ Concurrency in Action 一书，并顺应 C++17 于 2019 年 2 月出版了第二版。C++ Concurrency in Action 2ed 前五章介绍了线程支持库的基本用法，后六章从实践角度介绍了并发编程的设计**，相比第一版多介绍了一些 C++17 特性，如 std::scoped_lock、std::shared_mutex，并多出一章（第十章）介绍 C++17 标准库并行算法，此外个人会在相应处补充 C++20 相关特性，如 std::jthread、std::counting_semaphore、std::barrier、std::latch 等。阅读本书前可参考 Andrew S. Tanenbaum 的 Modern Operating Systems，预备操作系统的基础知识（进程与线程、死锁、内存管理、文件系统、I/O 等）。此为个人笔记，仅供参考，更详细内容见原书。

线程支持库

1. 线程管理（Managing thread）：<thread>
2. 线程间共享数据（Sharing data between thread）：<mutex>、<shared_mutex>
3. 同步并发操作（Synchronizing concurrent operation）：<condition_variable>、<semaphore>、<barrier>、<latch>、<future>、<chrono>、<ratio>
4. C++ 内存模型和基于原子类型的操作（The C++ memory model and operations on atomic type）：<atomic>

并发编程实践

5. 基于锁的并发数据结构的设计（Designing lock-based concurrent data structure）
6. 无锁并发数据结构的设计（Designing lock-free concurrent data structure）
7. 并发代码的设计（Designing concurrent code）
8. 高级线程管理（Advanced thread management）
9. 并行算法（Parallel algorithm）：<execution>
10. 多线程应用的测试与调试（Testing and debugging multithreaded application）

标准库相关头文件

头文件	说明
<thread>、<stop_token>	线程
<mutex>、<shared_mutex>	锁
<condition_variable>	条件变量
<semaphore>	信号量
<barrier>、<latch>	屏障
<future>	异步处理的结果
<chrono>	时钟
<ratio>	编译期有理数算数
<atomic>	原子类型和原子操作
<execution>	标准库算法执行策略

并发库对比

C++11 Thread

特性	API
thread	std::thread
mutex	std::mutex、std::lock_guard、std::unique_lock
condition variable	std::condition_variable、std::condition_variable_any
atomic	std::atomic、std::atomic_thread_fence
future	std::future、std::shared_future
interruption	无

Boost Thread

特性	API
thread	boost::thread
mutex	boost::mutex、boost::lock_guard、boost::unique_lock
condition variable	boost::condition_variable、boost::condition_variable_any
atomic	无
future	boost::future、boost::shared_future
interruption	thread::interrupt

POSIX Thread

特性	API
thread	pthread_create、pthread_detach、pthread_join
mutex	pthread_mutex_lock、pthread_mutex_unlock
condition variable	pthread_cond_wait、pthread_cond_signal
atomic	无
future	无
interruption	pthread_cancel

Java Thread

特性	API
thread	java.lang.Thread
mutex	synchronized blocks
condition variable	java.lang.Object.wait、java.lang.Object.notify
atomic	volatile 变量、java.util.concurrent.atomic
future	java.util.concurrent.Future
interruption	java.lang.Thread.interrupt
线程安全的容器	java.util.concurrent 中的容器
线程池	java.util.concurrent.ThreadPoolExecutor

cpp-concurrency-in-action-2ed's Issues

在“8.1.2　以递归方式划分数据”中的 parallel_quick_sort不能正常运行

下面是运行代码：
int main(){
std::list data = {5,1,2,9,100,8};
auto sorted_data = parallel_quick_sort(data);
for(auto it: sorted_data ){
printf("%d", it);
}
}
出错信息：
terminate called after throwing an instance of 'EmptyStack'
what(): empty stack!
[1] + Done "/usr/bin/gdb" --interpreter=mi --tty=${DbgTerm} 0<"/tmp/Microsoft-MIEngine-In-m25ftpou.0wk" 1>"/tmp/Microsoft-MIEngine-Out-xpupxdid.5th"

第3章 03_synchronizing_concurrent_operation的信号量小节的acquire()问题

acquire()的描述为
Atomically decrements the internal counter by 1 if it is greater than ​0​; otherwise blocks until it is greater than ​0​ and can successfully decrement the internal counter.
并不是acquire()即 P 操作，会在信号量值不小于 0 时将信号量减 1
应该修改acquire()即 P 操作，会在信号量值为不小于等于0 或者 大于0时将信号量减 1

关于线程池这一章的问题

“往线程池添加任务会增加任务队列的竞争，lock-free 队列可以避免这点但存在乒乓缓存的问题。为此需要把任务队列拆分为线程独立的本地队列和全局队列，当线程队列无任务时就去全局队列取任务”

在这一小节中，submit函数中的local_queue永远是nullptr，原因如下：
local_queue指针在worker_thread中赋值，woker_thread运行在子线程，而submit函数是在main线程中调用的，二者不是在同一线程，所以二者的local_queue根本不是同一个。

所以这段代码无法达到想要的目的。

some questions.

你好，我最近也在看这本书，我有一些疑问想跟你探讨一下不知你是否方便？

1. P20 ，The act of calling join() also cleans up any storage associated with the thread, so the std::thread object is no longer associated with the now-finished thread; it isn’t associated with any thread. 这句话我没太懂？

2. P22 The copy constructor and copy-assignment operators are marked =delete to ensure
   that they’re not automatically provided by the compiler. Copying or assigning such an
   object would be dangerous, because it might then outlive the scope of the thread it was
   joining. By declaring them as deleted, any attempt to copy a thread_guard object will
   generate a compilation error. 如果不将copy-assignment 定为 deleted的话，为什么是危险的呀？能否举一个例子？

应该是C++11规定 static local variable 的初始化是线程安全的和 copy assignment operator 漏写了字符 =

文件位置： content/02 线程间共享数据.md
https://github.com/downdemo/Cpp-Concurrency-in-Action-2ed/blob/cbd88caed525fffb736b4fe2fd3aa61a2d1f3bb2/content/02%20%E7%BA%BF%E7%A8%8B%E9%97%B4%E5%85%B1%E4%BA%AB%E6%95%B0%E6%8D%AE.md

Issue1

《C++ Concurrency in Action》Second Edition，Chapter 3.3.1 节最后部分关于 static变量 初始化的描述，仅指的是 static local variable 的初始化自 C++11 起是线程安全的，对于 static non-local variable 是未提及的，即对于具有静态存储期的非局部变量，如 global variable 和类的 static data member ，它们的初始化会作为程序启动的一部分在 main 函数的执行之前进行：简单的类型会在编译期进行初始化，如 constexpr 类型，复杂的类型则需要在运行期初始化，如 复杂的类对象（初始化时需要调用构造函数）。在程序结束时它们才会被销毁。因为 static non-local variable 的初始化会作为程序启动的一部分在 main 函数的执行之前进行，所以其初始化不存在多个线程竞争初始化的问题，但是却存在异常安全和 initialization order 的问题。详见 Static local variable and Global variable 。

即文中应该写为： “C++11规定static局部变量的初始化……”

Issue2

class A 的 copy assignment operator 漏写了字符 = ，即应该是： A& operator=(const A&) = delete;