《c++并发编程实战》 笔记

1、你好，C++的并发世界

为什么要使用并发

1、并发分离关注点的定义
并发分离关注点主要是指在并发编程中，通过将不同的逻辑或任务分离到不同的线程或进程中执行，从而实现关注点（即程序中需要特别关注或处理的部分）的分离。这种分离有助于简化程序结构，提高代码的可读性和可维护性。

2、使用并发提高性能，可用的方法

1. 第一个也是最明显的是将单个任务划分为多个部分并并行运行每个部分，从而减少总运行时间。
2. 第二个：数据并行性（Data Parallelism），即同时对多个数据集或数据块执行相同的操作或算法。

初始线程始于main()，而新线程始于hello()。

第2章 线程管理

2.1.1 启动线程

使用C++线程库启动线程，可以归结为构造std::thread对象：

std::thread

template< class Function, class... Args >  
explicit thread( Function&& f, Args&&... args );

• Function 是一个可调用对象（如函数指针、lambda 表达式、函数对象等）的类型。
• Args… 是传递给 Function的参数的类型列表。

std::thread 在 C++ 中扮演着核心角色，特别是在多线程编程领域。它的主要作用是提供一种机制来创建和管理线程，使得程序能够并行地执行多个任务。

• 创建新线程：通过 std::thread的构造函数，可以轻松地创建一个新线程来执行指定的函数或可调用对象。这允许开发者将耗时的操作或可以并行处理的任务放到单独的线程中执行，从而提高程序的性能和响应性。
• 管理线程生命周期：std::thread 对象与它所代表的线程紧密相关。通过调用 join() 或 detach()方法，可以管理线程的生命周期。join() 方法会阻塞当前线程，直到由 std::thread 对象表示的线程完成其执行。detach()方法则允许线程独立于 std::thread 对象运行，此时 std::thread对象不再拥有该线程，且无法再与之交互（除了获取其ID）。

线程可连接（joinable）是C++中std::thread对象的一个状态，它表示该std::thread对象代表了一个正在运行或已经启动但尚未结束的线程。当一个std::thread对象被创建并成功启动了一个新线程时，它就进入了可连接状态。

线程资源：
如线程栈、线程控制块等。如果这些资源在std::thread对象被销毁时仍未被释放，就会发生资源泄露。
在C++中，std::thread对象通过join()或detach()方法来管理其代表的线程。如果std::thread对象在销毁时仍然是可连接的（即线程仍在运行），且既未调用join()也未调用detach()，则程序会调用std::terminate()来终止执行，以防止潜在的资源泄露。
std::terminate会终止整个程序，而不是线程。操作系统会在程序终止时回收所有由该程序分配的资源。为了防止程序在不确定的线程状态下继续执行，因为此时线程可能还在访问或操作已经销毁的 std::thread 对象所管理的资源。

std::thread对象通常与特定的执行线程相关联，并且一旦线程执行完毕，std::thread对象就不再拥有任何线程（即变为空）。

线程的状态变化：

• 从非joinable到joinable：

  • 当通过调用std::thread的构造函数并传入一个可调用对象（如函数指针、Lambda表达式、绑定表达式等）来创建std::thread对象时，如果构造函数成功，则新创建的线程对象将处于joinable状态。这意呀着你可以对该线程调用join()来等待它完成，或者调用detach()来分离它。

• 从joinable到非joinable：

  • 一旦对joinable的线程调用了join()或detach()，该线程对象就不再处于joinable状态。对已经join或detach的线程对象再次调用join()或detach()将导致std::system_error异常。
  • 如果线程的执行函数已经返回（即线程已结束），并且你尚未对该线程调用join()或detach()，则尝试对该线程对象调用join()，detach仍然有效，但调用后将使线程对象变为非joinable。
  • 如果线程对象被销毁时仍然处于joinable状态（即没有调用join()或detach()），则程序将调用std::terminate()来终止执行，以避免资源泄露。因此，重要的是要确保在销毁std::thread对象之前，要么调用join()要么调用detach()。

2.2 向线程函数传递参数

参数要拷贝到线程独立内存中，即使参数是引用的形式，也可以在新线程中进行访问。

一定要使用引用：
std::ref 用于创建一个对给定对象的引用封装器（reference wrapper），这个封装器可以被存储在容器中，或者作为函数参数传递给需要复制语义但实际上需要引用语义的地方。简而言之，std::ref 允许你以引用的方式传递对象，即使是在需要拷贝的上下文中。

std::bind 是 C++ 标准库中的一个功能强大的工具，它定义在头文件 中。std::bind 用于将可调用对象（如函数、函数对象、lambda 表达式、成员函数指针等）与其参数绑定在一起，生成一个新的可调用对象。这个新的可调用对象在调用时，会调用原始的可调用对象，并传递给它预先绑定的参数（如果有的话），以及调用新可调用对象时提供的任何额外参数。

2.5 识别线程

2种方法

• 第一种，可以通过调用std::thread对象的成员函数get_id()来直接获取。如果std::thread对象没有与任何执行线程相关联，get_id()将返回std::thread::type默认构造值，这个值表示“没有线程”。
• 第二种，当前线程中调用std::this_thread::get_id()(这个函数定义在头文件中)也可以获得线程标识。

第3章 线程间共享数据

3.2.1 C++中使用互斥量

C++中通过实例化std::mutex创建互斥量，通过调用成员函数lock()进行上锁，unlock()进行解锁。实践中更推荐使用RAII语法的模板类std::lock_guard。

加了锁之后，还需要注意：被保护量不会通过指针或引用方式传递到外部去。

避免死锁的进阶指导

死锁定义：它指的是两个或多个线程在执行过程中，因争夺资源而造成的一种僵局（互相等待）。

避免死锁的方法：

1. 避免使用多个锁
2. 保持锁的顺序一致
3. 避免嵌套锁
4. 使用超时机制
5. 使用标准库中的工具
   C++标准库提供了一些工具来帮助避免死锁，如std::lock和std::scoped_lock。
   std::lock可以一次性为多个互斥量上锁，并且内部使用死锁避免算法。
   std::lock_guard RAII（Resource Acquisition Is Initialization）原则，这意味着资源的获取（在这里是互斥量的加锁）是在对象的构造函数中完成的，而资源的释放（在这里是互斥量的解锁）则是在对象的析构函数中完成的。
   std::scoped_lock是一种RAII（Resource Acquisition Is Initialization）风格的锁管理器，它可以在构造时自动上锁，并在析构时自动解锁，从而简化了锁的管理。对多个锁进行操作，C++ 17引入。
   std::unique_lock提供了比 std::lock_guard 更加灵活的互斥量封装。std::unique_lock 提供了更多的控制，包括延迟加锁、尝试加锁、定时加锁以及手动解锁和重新加锁的能力。
6. 持有锁的时间尽可能少，减少死锁概率。

保护共享数据的替代设施

保护共享数据的初始化过程

双重检查锁存在的问题：
由于C++11之前的内存模型并没有提供足够的保证来防止指令重排序，因此在多线程环境中使用双重检查锁模式可能会导致未定义行为，比如访问未完全初始化的对象。

std::call_once 是 C++11 引入的一个函数，它属于 头文件。这个函数的主要用途是确保某个函数或可调用对象只被执行一次，即使它被多次调用。这对于初始化全局变量或执行只需要执行一次的昂贵操作特别有用。

std::call_once 的使用通常与 std::once_flag 类型的标志一起，这个标志用来指示函数是否已经被调用过。如果函数已经被调用，那么后续的调用将不会执行任何操作。

在C++11标准中，静态局部变量即便在多线程中，也只被初始化一次。

保护很少更新的数据结构（读多写少）
boost::shared_mutex 是 Boost 库中的一个同步原语，它允许多个线程以共享模式（shared mode）同时读取数据，但写入数据时需要独占访问。
使用 boost::shared_lockboost::shared_mutex 来获取共享锁。
使用 std::unique_lockboost::shared_mutex 来获取独占锁。
本质和读写锁类似。

嵌套锁
std::recursive_mutex，支持一个线程尝试锁多次。适用于获取锁的时候用到了其他函数，其他函数也访问这个锁。
更好的替代方法是：考虑是否可以重新设计函数逻辑，避免递归调用，从而无需使用递归互斥锁。

第4章 同步并发操作

线程会等待一个特定事件的发生，或者等待某一条件达成(为true)。像这种情况就需要在线程中进行同步，C++标准库提供了一些工具可用于同步操作，形式上表现为条件变量(condition variables)和期望(futures)。

4.1 等待一个事件或其他条件

条件变量：condition_variable
是利用线程间共享的变量进行同步的一种机制。在多线程程序中，条件变量常用于实现“等待–>唤醒”逻辑，用于维护一个条件（注意区分条件变量与条件本身），线程可以使用条件变量来等待某个条件为真。
常与锁结合。

条件变量的基本原理包括两个主要动作：
等待：当某个条件不满足时，一个线程会将自己加入等待队列，并释放持有的互斥锁（Mutex），进入睡眠状态等待条件成立。wait函数，需要带条件，可能虚假唤醒。
唤醒：当条件满足时，另一个线程会通知（signal或broadcast）等待在条件变量上的线程，唤醒它们重新检查条件。被唤醒的线程会重新尝试获取互斥锁，并在获取锁后继续执行。notify_one()与notify_all()。

4.2 使用期望等待一次性事件

std::future
获得一个 std::future 对象，这个对象将在未来某个时间点持有异步操作的结果。
关键函数：

• get()：这个函数阻塞当前线程，直到异步操作完成，并返回操作的结果。如果异步操作抛出了异常，get()
  函数将重新抛出该异常。注意，get() 只能被调用一次，因为一旦结果被取出，std::future 对象就不再持有任何结果了。
• wait()：这个函数也会阻塞当前线程，但它只是等待异步操作完成，而不返回结果。如果只是想等待异步操作完成而不关心结果，可以使用这个函数。
• wait_for() 和wait_until()：这两个函数提供了更灵活的等待机制。它们允许你指定一个时间段或时间点，然后在这个时间段内等待异步操作完成。如果操作在这段时间内完成了，函数将返回std::future_status::ready；如果操作没有完成，函数将返回 std::future_status::timeout或 std::future_status::deferred（对于 std::async 启动的异步任务，后者几乎不会出现）。
• valid()：这个函数检查 std::future 对象是否还持有有效的异步操作结果。一旦 get()被调用或异步操作被取消，valid() 将返回 false。

std::async
是 C++11 标准库中的一个函数模板，它提供了一种方便的方式来启动一个异步任务。当你调用 std::async 时，你可以指定要执行的函数（或可调用对象）、传递给该函数的参数，以及一个启动策略（可选）。std::async 返回一个 std::future 对象，这个对象将在未来某个时间点持有异步操作的结果。
启动策略：

• std::launch::async：指示 std::async 应该异步地执行函数，即在新线程或线程池中执行。如果系统无法立即启动新线程，则行为是未定义的（尽管在实际的 C++ 实现中，它通常会阻塞直到能够启动新线程）。
• std::launch::deferred：指示 std::async 应该延迟执行函数，直到调用返回的 std::future 对象的 wait() 或 get() 方法。此时，函数将在调用这些方法的线程中同步执行。
  如果省略启动策略，则 std::async 可能会选择 std::launch::async 或 std::launch::deferred，或者在某些情况下甚至可能使用混合策略。然而，这种混合模式的使用是不确定的，因此最好明确指定你想要的启动策略。

std::packaged_task<>
是 C++11 标准库中提供的一个模板类，它封装了一个可调用对象（如函数、lambda 表达式、绑定表达式等），使得这个可调用对象可以异步执行。可以通过调用 std::packaged_task<> 的 operator() 来异步地执行封装的可调用对象（比std::async更灵活）。

使用std::promises
是 C++11 标准库中提供的一个类模板，它用于在异步编程中设置值或异常，以便与 std::future 对象共享这些值或异常。std::promise 和 std::future 一起工作，以支持跨线程的值传递和异常传播。

主要函数：

• get_future(): 返回与 std::promise 对象关联的 std::future 对象。这个函数只能被调用一次。
• set_value(T value): 设置 std::promise 对象的值。这个函数只能被调用一次，并且只能在std::promise 对象被销毁之前调用。
• set_exception(std::exception_ptr p): 设置std::promise 对象的异常。这个函数也只能被调用一次，并且只能在 std::promise 对象被销毁之前调用。

多个线程的等待同一个事件
使用std::shared_future::wait,std::shared_future 与 std::future 类似，但主要区别在于 std::shared_future 可以被多个线程或对象共享，而 std::future 一旦被移动或拷贝后，原始对象将不再持有任何结果，变成空状态。

第6章 基于锁的并发数据结构设计

4.2 使用期望等待一次性事件