C++11 标准库中的多线程支持。内容包括线程对象的构造方式（无参、带参、移动）、线程生命周期管理（join、detach）、互斥锁种类（mutex、recursive_mutex 等）及 RAII 封装（lock_guard、unique_lock）。此外还讲解了条件变量的 wait/notify 机制以及原子操作库 atomic 如何解决线程安全问题，提供了相关代码示例。
在 C++11 之前，涉及到的多线程问题通常都是和平台相关的，比如 Windows 和 Linux 下各有自己的接口，这使得代码的可移植性比较差。C++11 中最重要的特性就是对线程进行了支持，使得 C++ 并行编程时不需要依赖第三方库，从而解决了这个问题，而且在原子操作中还引入了原子类的概念。
要使用标准库中的线程，必须包含 <thread> 头文件。
注意：
thread 提供了无参的构造函数，调用无参的构造函数创建出来的线程对象没有关联任何线程入口函数，也就是没有启动任何线程。
thread t1;
那后续如何启动线程呢？
由于 thread 提供了移动赋值函数，因此当后续需要让该线程对象与线程函数关联时，可以以带参的方式创建一个匿名对象，然后调用移动赋值将该匿名对象关联线程的状态转移给该线程对象。 如下：
// 线程入口函数
void handler(int n) {
for (int i = 0; i <= n; i++) {
cout << i << endl;
}
}
int main() {
thread t1;
// 带参创建匿名对象移动赋值给 t1
t1 = thread(handler, 10);
t1.join(); // 等待线程
return 0;
}
应用场景：实现线程池的时候就是需要先创建一批线程，但一开始这些线程什么也不做，当有任务到来时再让这些线程来处理这些任务。类似于懒汉模式的思想，可以提高程序效率。
template<class Fn, class... Args>
explicit thread(Fn&& fn, Args&&... args);
参数说明：
fn：可调用对象。比如函数指针、仿函数、lambda 表达式、被包装器包装后的可调用对象等。args...：调用可调用对象 fn 时所需要的若干参数。调用带参的构造函数创建线程对象，能够直接将线程对象与线程函数 fn 进行关联。
示例如下：
// 线程入口函数
void handler(int n) {
for (int i = 0; i <= n; i++) {
cout << i << endl;
}
}
int main() {
thread t2(handler, 10);
t2.join();
return 0;
}
thread 提供了移动构造函数，能够用一个右值线程对象来构造一个线程对象。
// 线程入口函数
void handler(int n) {
for (int i = 0; i <= n; i++) {
cout << i << endl;
}
}
int main() {
thread t3 = thread(handler, 10);
t3.join();
return 0;
}
注意：
常用的成员函数如下：
| 成员函数 | 功能 |
|---|---|
| join | 对该线程进行等待，在等待的线程返回之前，调用 join 函数的线程将会被阻塞 |
| joinable | 判断该线程是否已经执行完毕，如果是则返回 true，否则返回 false |
| detach | 将该线程与创建线程进行分离，被分离后的线程不再需要创建线程调用 join 函数对其进行等待 |
| get_id | 获取该线程的 id |
| swap | 将两个线程对象关联线程的状态进行交换 |
joinable 函数还可以用于判定线程是否是有效的，如果是以下任意情况，则线程无效：
获取线程的 id 的方式有两种，适用于不同的使用场景：
std::this_thread::get_id：用于获取当前正在执行的线程的 ID。
使用场景: 当你在某个线程内部，并且想要知道该线程的 ID 时，可以使用这个函数。
示例：
#include <iostream>
#include <thread>
void foo() {
std::cout << "Current Thread ID: " << std::this_thread::get_id() << std::endl;
}
int main() {
std::thread t(foo);
t.join();
return 0;
}
std::thread::get_id：用于获取特定 std::thread 对象所代表的线程的 ID。
使用场景: 当你有一个 std::thread 对象，并且想要知道它代表的线程的 ID 时，可以使用这个成员函数。示例：
#include <iostream>
#include <thread>
void foo() {
// 一些操作...
}
int main() {
std::thread t(foo);
std::cout << "Thread ID: " << t.get_id() << std::endl;
t.join();
return 0;
}
此外，this_thread 命名空间中还提供了以下三个函数：
| 函数名 | 功能 |
|---|---|
| yield | 当前线程'放弃'执行，让操作系统调度另一线程继续执行 |
| sleep_until | 让当前线程休眠到一个具体时间点 |
| sleep_for | 让当前线程休眠一个时间段 |
启动一个线程后，当这个线程退出时，需要对该线程所使用的资源进行回收，否则可能会导致内存泄露等问题（类比于进程等待来理解）。
thread 库给我们提供了如下两种回收线程资源的方式：
join 方式
主线程创建新线程后，可以调用 join 函数等待新线程终止，当新线程终止时 join 函数就会自动清理线程相关的资源。
join 函数清理线程的相关资源后，thread 对象与已销毁的线程就没有关系了，因此一个线程对象一般只会使用一次 join，否则程序会崩溃。
void foo(int n) {
for (int i = 0; i <= n; i++) {
cout << i << endl;
}
}
int main() {
thread t(foo, 20);
t.join();
t.join(); // 程序崩溃
return 0;
}
detach 方式
主线程创建新线程后，也可以调用 detach 函数将新线程与主线程进行分离，分离后新线程会在后台运行，其所有权和控制权将会交给 C++ 运行库，此时 C++ 运行库会保证当线程退出时，其相关资源能够被正确回收。
使用示例：
void foo(int n) {
// 当前线程与主线程分离
for (int i = 0; i <= n; i++) {
cout << i << endl;
}
}
int main() {
thread t(foo, 20);
// 无需 join 等待
return 0;
}
注意：
joinable 判断这个线程是否需要被 join，如果需要那么就会调用 terminate 终止当前程序（程序崩溃）。线程函数的参数是以值拷贝的方式拷贝到线程栈空间中的，就算线程函数的参数为引用类型，在线程函数中修改后也不会影响到外部实参，因为其实际引用的是线程栈中的拷贝，而不是外部实参。
比如：
void add(int& num) {
num++;
}
int main() {
int num = 0;
thread t(add, num);
t.join();
cout << num << endl; // 0
return 0;
}
尽管 add 函数的参数类型是引用，但 num 最终还是 0。
像这种要通过线程函数的形参改变外部的实参，有以下三种方式：
方式一：借助 std::ref 函数（常用）
在传入实参时需要借助 ref 函数可以保持对实参的引用。
示例：
void add(int& num) {
num++;
}
int main() {
int num = 0;
thread t(add, ref(num));
t.join();
cout << num << endl; // 1
return 0;
}
方式二：地址的拷贝（指针）
将线程函数的参数类型改为指针类型，将实参的地址传入线程函数，此时在线程函数中可以通过修改该地址处的变量，进而影响到外部实参。
示例：
void add(int* num) {
(*num)++;
}
int main() {
int num = 0;
thread t(add, &num);
t.join();
cout << num << endl; // 1
return 0;
}
方式三：借助 lambda 表达式
将 lambda 表达式作为线程函数，利用 lambda 函数的捕捉列表，以引用的方式对外部实参进行捕捉，此时在 lambda 表达式中对形参的修改也能影响到外部实参。
示例：
int main() {
int num = 0;
thread t([&num]{ num++; });
t.join();
cout << num << endl; // 1
return 0;
}
在 C++11 中，mutex 总共包含了四个互斥量的种类：
C++11 提供的最基本的互斥量，该类的对象之间不能拷贝，也不能移动拷贝。
mutex 中最常用的成员函数如下：
| 成员函数 | 功能 |
|---|---|
| lock | 对互斥量进行加锁 |
| try_lock | 尝试对互斥量进行加锁 |
| unlock | 对互斥量进行解锁，释放互斥量的所有权 |
注意，线程函数调用 lock 时，可能会发生以下三种情况：
unlock 之前，该线程一直拥有该锁。线程函数调用 try_lock 时，可能会发生以下三种情况：
recursive_mutex 叫做递归互斥锁，该锁专门用于递归函数中的加锁操作。
unlock。除此之外，recursive_mutex 也提供了 lock、try_lock 和 unlock 成员函数，其的特性与 mutex 大致相同。
timed_mutex 中额外提供了以下两个成员函数：
try_lock_for：接受一个时间范围，表示在这一段时间范围之内，调用线程如果没有获得锁则被阻塞住，如果在此期间有其他线程释放了锁，则该线程获得这个锁，如果超时，则放回 false。try_lock_until：接受一个时间点作为参数，在指定时间点未到来之前线程如果没有获得锁则被阻塞住，如果在此期间有其他线程释放了锁，则该线程获得这个锁，如果超时，则返回 false。除此之外，timed_mutex 也提供了 lock、try_lock 和 unlock 成员函数，其的特性与 mutex 相同。
顾名思义，recursive_timed_mutex 就是 recursive_mutex 和 timed_mutex 的结合，recursive_timed_mutex 既支持在递归函数中进行加锁操作，也支持定时尝试申请锁。
对于我们来说，使用互斥锁最担忧的事情就是忘记释放锁，特别是在加锁的范围太大的时候。此后申请这个互斥锁的线程就会被阻塞住，也就是造成了死锁问题。
最常见的就是此处在锁中间代码函数返回，此外还有一个比较常见的情况就是在锁的范围内抛异常，也很容易导致死锁问题。
因此 C++11 采用 RAII 的方式对锁进行了封装，于是就出现了 lock_guard 和 unique_lock。
lock_guard
lock_guard 是 C++11 中的一个模板类，其定义如下：
template<class Mutex>
class lock_guard;
lock_guard 类模板主要是通过 RAII 的方式，对其管理的互斥锁进行了封装。
使用方法：
通过这种构造对象时加锁，析构对象时自动解锁的方式就有效的避免了死锁问题。 示例：
void foo(mutex &mtx) {
lock_guard<mutex> lg(mtx); // 调用构造函数加锁
// ...
FILE* fout = fopen("data.txt", "r");
if (fout == nullptr) {
// ...
return; // 调用析构函数解锁
}
// ...
} // 调用析构函数解锁
int main() {
mutex mtx;
thread t(foo, std::ref(mtx));
return 0;
}
从 lock_guard 对象定义到该对象析构，这段区域的代码都属于互斥锁的保护范围。
如果只想用 lock_guard 保护某一段代码，可以通过定义匿名的局部域来控制 lock_guard 对象的生命周期。比如：
void foo(mutex &mtx) {
// ...
// 匿名局部域
{
lock_guard<mutex> lg(mtx); // 调用构造函数加锁
FILE* fout = fopen("data.txt", "r");
if (fout == nullptr) {
// ...
return; // 调用析构函数解锁
}
} // 调用析构函数解锁
// ...
} // 调用析构函数解锁
int main() {
mutex mtx;
thread t(foo, std::ref(mtx));
return 0;
}
unique_lock
由于lock_guard 太单一，用户没有办法对锁进行控制，因此 C++11 又提供了 unique_lock。
unique_lock 与 lock_guard 类似，unique_lock 类模板也是采用 RAII 的方式对锁进行了封装。在创建 unique_lock 对象调用构造函数时也会调用 lock 进行加锁，在 unique_lock 对象销毁调用析构函数时也会调用 unlock 进行解锁。
不同的是，unique_lock 更加的灵活，提供了更多的成员函数：
condition_variable 中提供的成员函数，可分为 wait 系列和 notify 系列两类。
wait 系列成员函数的作用就是让调用线程进行阻塞等待，包括 wait、wait_for 和 wait_until。
先来看看 wait，在 C++11 中它有两个版本：
// 版本一
void wait(unique_lock<mutex>& lck);
// 版本二
template<class Predicate>
void wait(unique_lock<mutex>& lck, Predicate pred);
函数说明：
为什么调用 wait 系列函数时需要传入一个互斥锁？
wait_for 和 wait_until 函数的使用方式与 wait 函数类似：
注意：调用 wait 系列函数时，传入互斥锁的类型必须是 unique_lock。
notify 系列成员函数的作用就是唤醒等待的线程。 包括：
notify_one：唤醒等待队列中的首个线程，如果等待队列为空则什么也不做。notify_all：唤醒等待队列中的所有线程，如果等待队列为空则什么也不做。注意：条件变量下可能会有多个线程在进行阻塞等待，这些线程会被放到一个等待队列中进行排队。
多线程最主要的问题是共享数据带来的数据二义性问题（即线程安全）。
如果共享数据都是只读的，就没啥问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。
但是，当一个或多个线程要修改共享数据时，如果修改数据的操作是原子性的，就没问题，否则就会产生很多潜在的麻烦。
原子性操作（感性的定义）：这个操作要么没做，要么就做完了。
原子性操作（计算机中的定义）：一个操作只由一条汇编语句完成且该汇编语句属于简单汇编指令。
就比如 ++ 操作就不是一个原子操作，该操作分为三条汇编语句：
load：将共享变量 n 从内存加载到寄存器中。update：更新寄存器里面的值，执行 +1 操作。store：将新值从寄存器写回共享变量 n 的内存地址为什么不是原子操作就不安全了呢？
因为 CPU 调度线程是给予有限的时间片的，在时间片耗尽前不能保证非原子操作一定完成，很可能会卡在操作中间，就比如会在 ++ 操作的 store 就被切走了，此时调度其他线程，可能完整地执行了一次 ++ 操作，当这个线程再重新被调度时，加载线程上下文继续执行 store，而这个变量却已经被其他线程 ++ 过了，最终就会导致两个线程分别对共享变量 n 进行了一次 ++ 操作，但最终 n 的值却只被 ++ 了一次。
加锁解决线程安全问题
C++98 中对于这里出现的线程安全的问题，我们只需要选择性对修改共享数据的操作进行加锁保护即可。
原子类解决线程安全问题
C++11 中引入了原子操作类型，它可以使得对该类型的变量的操作转化为原子操作，使得线程间数据的同步变得非常高效。
如下：
| 原子类型名称 | 对应的内置类型名称 |
|---|---|
| atomic_bool | bool |
| atomic_char | char |
| atomic_schar | signed char |
| atomic_uchar | unsigned char |
| atomic_int | int |
| atomic_uint | unsigned int |
| atomic_short | short |
| atomic_ushort | unsigned short |
| atomic_long | long |
| atomic_ulong | unsigned long |
| atomic_llong | long long |
| atomic_ullong | unsigned long long |
| atomic_char16_t | char16_t |
| atomic_char32_t | char32_t |
| atomic_wchar_t | wchar_t |
注意：需要使用以上原子操作变量时，必须添加头文件
在 C++11 中，程序员不需要对原子类型变量进行加锁解锁操作，线程能够对原子类型变量互斥的访问。
更为普遍的，程序员可以使用 atomic 类模板，定义出需要的任意原子类型。
atomic<T> t; // 声明一个类型为 T 的原子类型变量 t
注意：
#include <atomic>
int main() {
atomic<int> a1(0);
// atomic<int> a2(a1); // 编译失败
atomic<int> a2(0);
// a2 = a1; // 编译失败
return 0;
}
原子类型不仅仅支持原子的 ++ 操作，还支持原子的 –、加一个值、减一个值、与、或、异或操作。
拓展学习：CAS 无锁编程
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online