《C++并发编程实战》读书笔记（1）：并发、线程管控

C语言与CPP编程 2023-06-06 10:18

【有奖直播】深入学习Microchip时钟和全新单片机方案 【有奖直播】提升毫米波信号测试精度

点击上方“C语言与CPP编程”，选择“关注/置顶/星标公众号”

干货福利，第一时间送达！

你好，我是飞宇。

昨天在朋友圈分享了一下自己关于《C++并发编程实战》这本书的读书笔记，收到不少点赞，今天就在公众号上分享一下自己以前的读书笔记，今天先更新第一部分，后续的读书笔记会慢慢再慢慢更新好了。

这里也顺便放一下自己的个人联系方式的二维码，听说以后公众号后不可以放二维码了，我也会经常在微信上分享一些计算机学习经验以及工作体验，还有一些内推工作机会，一般不闲聊，欢迎来做点赞之交。

C++国内并发编程的书少得可怜，唯一本质量还稍微靠谱点的就这本了《C++并发编程实战》，算是矮子里了挑将军挑出来的吧，我看的是这本

《C++并发编程实战》是关于C++新标准涉及的并发与多线程功能的深度指南，从std::thread、std::mutex和std::async的基本使用方法开始，一直到复杂的内存模型和原子操作。

第二版的英文原版与中译本都很容易购买。此外，github上也有其中文翻译https://github.com/xiaoweiChen/CPP-Concurrency-In-Action-2ed-2019以及示例代码汇总https://github.com/anthonywilliams/ccia_code_samples

第1章你好，C++并发世界

计算机系统中的并发包括任务切换与硬件并发，往往同时存在，关键因素是硬件支持的线程数。不论何种，本书谈论的技术都适用。

采用并发的理由主要是分离关注点与提升性能。但并发使得代码复杂、难懂、易错，不值得时无需采用并发。

并发的方式包括多进程与多线程。前者采用多个进程，每个进程只含一个线程，开销更大，通过昂贵的进程间通信来传递信息，但更安全并且可利用网络连接在不同计算机上并发。后者采用单一进程，内含多个线程，额外开销更低，但难以驾驭，往往暗含隐患。本书专攻多线程并发。

并发与并行都指可调配的硬件资源同时运行多个任务，但并行更强调性能，而并发更强调分离关注点或相应能力。

以一个简单的例子开启本书：

#include #include 
void hello() { std::cout << "Hello Concurrent World\n"; }
int main() {    std::thread t(hello);    // join令主线程等待子线程    t.join();}

第2章线程管控

2.1 线程的基本管控

每个C++程序都含有至少一个线程，即main函数所在线程。随后，程序可通过std::thread启动更多线程；它需要头文件，可以通过任何可调用类型（函数、伪函数、lambda等）发起线程。

void do_some_work();std::thread my_thread(do_some_work);

启动线程后需要决定是与之汇合（join）还是与之分离（detach）。如果线程销毁时还没决定，那么线程会调用std::terminate终止整个程序。只有存在关联的执行线程时，即t.joinable()返回true，才能调用join/detach。

detach成员函数表示程序不等待线程结束，令线程在后台运行，归属权与控制权转交给C++运行时库。使用detach需确保所访问的外部数据始终正确有效，避免持有主线程的局部变量的指针/引用，否则主线程退出后该线程可能持有空悬指针/空悬引用。解决办法是将数据复制到新线程内部而非共享，或者使用join而非detach。

join成员函数的作用是等待线程的执行结束并回收线程资源；只能调用一次，之后就不再joinable。为了防止抛出异常时跳过join，导致程序崩溃有，可以实现一个RAII类，在析构函数中保证已经汇合过。

class thread_guard {    std::thread& t_;
   public:    explicit thread_guard(std::thread& t) : t_(t) {}    ~thread_guard() {        if (t_.joinable()) {            t_.join();        }    }    thread_guard(thread_guard const&) = delete;    thread_guard& operator=(thread_guard const&) = delete;};

2、向线程函数传递参数

直接向std::thread的构造函数添加更多参数即可给线程函数传递参数。不过参数是先按默认方式复制到线程内部存储空间，再被当成临时变量以右值形式传给线程函数。

例如下面的字符串字面量hello，先以const char*形式传入，再转化为std::string类型。

void f(const std::string &);std::thread t(f,"hello");

但如果实参是指针，那么传入指针后构造string时，指针可能已经空悬。解决办法是传参时直接转换为string。

std::thread t(f,std::string(buffer));

如果线程函数的形参是左值引用，直接传入实参会被转化为右值再传入，导致错误。解决办法是用std::ref加以包装。

void f(int &i) { std::cout << i; }
int main() {    int i = 3;    std::thread t(f, std::ref(i));}

想要使用成员函数作为线程函数的话，还需传入对象指针。例如下面的线程函数实际上调用w.f(i)。

class Widget {   public:    void f(int i) { cout << i; }};
int main() {    Widget w;    int i = 4;    std::thread t(&Widget::f, &w, i);    t.join();}

对于只能移动不能拷贝的参数，例如unique_ptr，若实参是临时变量则自动移动，若实参是具名变量则需使用move。

void f(std::unique_ptr);
auto p = make_unique();std::thread t(f,std::move(p));

2.3 移交线程归属权

thread掌握资源，像unique_ptr一样只能移动不能拷贝；此外当thread关联一个线程时向其移动赋值会导致程序终止。支持移动操作的容器，例如vector，可以装载std::thread对象。

可以改进前文的thread_guard，使其支持构建并掌管线程，确保离开所在作用域前线程已完结。

class scoped_thread {    std::thread t;
   public:    explicit scoped_thread(std::thread t_) : t(std::move(t_)) {        if (!t.joinable()) throw std::logic_error("No thread");    }    ~scoped_thread() { t.join(); }    scoped_thread(scoped_thread const&) = delete;    scoped_thread& operator=(scoped_thread const&) = delete;};
// 使用统一初始化避免被解析为函数声明scoped_thread t{std::thread(f)};

2.4 在运行时选择线程数量、线程ID

可以通过std::thread::hardware_concurrency()来获取可真正并发的线程数量，硬件信息无法获取时返回0。当用多线程分解任务时，该值是有用的指标。

以下是并行版accumulate的简易实现，根据硬件线程数计算实际需要运算的线程数，随后将任务分解到各个线程处理，最后汇总得到结果。

// 每个线程运行的子任务template <typename Iterator, typename T>struct accumulate_block {    void operator()(Iterator first, Iterator last, T& result) {        result = std::accumulate(first, last, result);    }};
template <typename Iterator, typename T>T parallel_accumulate(Iterator first, Iterator last, T init) {    unsigned long const length = std::distance(first, last);    if (!length) return init;    // 每个线程至少处理25个元素    unsigned long const min_per_thread = 25;    unsigned long const max_threads =        (length + min_per_thread - 1) / min_per_thread;    unsigned long const hardware_threads = std::thread::hardware_concurrency();    // 无法获取硬件线程数时设置为2    unsigned long const num_threads =        std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);    unsigned long const block_size = length / num_threads;        std::vector results(num_threads);    // 创建n-1个线程，因为本线程也进行运算任务    std::vector<std::thread> threads(num_threads - 1);
    Iterator block_start = first;    for (unsigned long i = 0; i < (num_threads - 1); ++i) {        Iterator block_end = block_start;        std::advance(block_end, block_size);        threads[i] = std::thread(accumulate_block(), block_start,                                 block_end, std::ref(results[i]));        block_start = block_end;    }    accumulate_block()(block_start, last,                                    results[num_threads - 1]);
    std::for_each(threads.begin(), threads.end(),                  std::mem_fn(&std::thread::join));
    return std::accumulate(results.begin(), results.end(), init);}

线程ID的类型是std::thread::id，可随意复制或比较。可以通过thread的get_id()成员函数获取，也可以通过std::this_thread::get_id()获取当前线程ID。

第3章在线程间共享数据

3.1 线程间共享数据的问题

并发编程中操作由多个线程负责，争先让线程执行各自的操作，结果取决于它们执行的相对顺序，这就是条件竞争。恶性条件竞争会导致未定义行为。很经典的两个线程各自递增一个全局变量十万次的例子，理想情况下最后变量变为二十万，然而实际情况是这样：

3.2 用互斥保护共享数据

可以利用名为互斥的同步原语。C++线程库保证了一旦由线程锁住某个互斥，其他线程试图加锁时必须等待，直到原先加锁的线程将其解锁。注意应以合适的粒度加锁，仅在访问共享数据期间加锁，处理数据时尽可能解锁。

C++中通过构造std::mutex的实例来创建互斥，通过lock/unlock成员函数来加锁解锁。并不推荐直接调用成员函数，应使用其RAII类lock_guard，构造时加锁、析构时解锁。

// 使用互斥锁来保护some_liststd::list<int> some_list;std::mutex some_mutex;
void add_to_list(int new_value){    std::lock_guard<std::mutex> guard(some_mutex);    some_list.push_back(new_value);}
//C++17支持类模板参数推导与scoped_lockvoid add_to_list(int new_value){    std::scoped_lock guard(some_mutex);    some_list.push_back(new_value);}

然而仍可能出现未被保护的指针/引用，或者成员函数调用了不受掌控的其他函数，因此不能向锁所在的作用域之外传递受保护数据的指针/引用。然而即使用互斥保护，有些接口仍存在固有的条件竞争。例如对于栈来说：线程1判断栈非空，随后线程2取出元素，栈空，随后线程1取出元素时出错。下面是一个解决办法的示例：‍

template <typename T>class threadsafe_stack {   public:    std::shared_ptr pop() {        std::lock_guard<std::mutex> lock(m);        if (data.empty()) throw empty_stack();        std::shared_ptr const res(std::make_shared(data.top()));        data.pop();        return res;    }    void pop(T& value) {        std::lock_guard<std::mutex> lock(m);        if (data.empty()) throw empty_stack();        value = data.top();        data.pop();    }    ...};

最后，死锁是指两个线程都需要锁住两个互斥锁才能继续运行，而目前都只锁住一个，并苦苦等待对方解锁。以下是一些防范死锁的准则：1、如果已经持有锁，就不要获取第二个锁；确实需要获取多个锁时使用std::lock来一次性获取所有锁。2、一旦持锁，避免调用用户提供的程序接口避免嵌套锁。3、依从固定顺序获取锁。4、按层级加锁。5、事实上任何同步机制的循环等待都会导致死锁。

例如swap函数需要同时获取双方的锁时：

class X {   public:    friend void swap(X& lhs, X& rhs) {        if (&lhs == &rhs) return;        std::lock(lhs.m, rhs.m);    // adopt_lock表示lhs.m已经上锁        std::lock_guard<std::mutex> lock_a(lhs.m, std::adopt_lock);        std::lock_guard<std::mutex> lock_b(rhs.m, std::adopt_lock);        swap(lhs.some_detail, rhs.some_detail);    }        // C++17中    friend void swap(X& lhs, X& rhs){        if (&lhs == &rhs) return;        std::scoped_lock guard(lhs.m,rhs.m);        swap(lhs.some_detail, rhs.some_detail);    }};

unique_lock比lock_guard更灵活，不占有与之关联的互斥锁，但占用更多空间并且更慢。它提供了lock/try_lock/unlock成员函数；构造函数第二个参数传入adopt_lock表示互斥锁已上锁，传入defer_lock表示构造时无需上锁。unique_lock可移动不可复制，可以在不同作用域间转移互斥所有权，用途是让程序在同一个锁的保护下执行其他操作。

3.3 保护共享数据的其他工具

可以通过once_flag类和call_once函数来在初始化过程中保护共享数据。

std::once_flag resource_flag;void init_resource(){ .. }
void run(){  std::call_once(resource_flag, init_resource);  ...}

C++11还规定了静态数据只会初始化一次。那么单例模板类可以这样实现：

template<class T>class Singleton {public:    static T& Instance() {        static T instance;        return instance;    }
protected:    Singleton() = default;    ~Singleton() = default;
private:    Singleton(const Singleton&) = delete;    Singleton& operator=(const Singleton&) = delete;};// 使用方法：class MyClass : public Singleton {public:    ...private:    MyClass();    friend class Singleton;};