这篇文章应我朋友的邀请，写一篇文章介绍下C++多线程。
编译环境准备
首先确定你的编译器支持std的thread，如果不支持，就会出现诸如“thread找不到”的问题。
以下假设你使用 gnu gcc 编译器，因为 MSVC 的我也不太熟悉。
linux
std::thread 在 Linux 上的实现借用了 Linux 的 pthread，因此，编译选项需要加入
-pthread
Windows
如果是 Windows，首先要确保你的 mingw gcc 使用的是 posix 接口。如果是 Win32 接口则不可以使用 std 的 thread，尽管你也能在代码里 include thread 的头文件，但是宏定义会禁止使用头文件里的代码。当然，win32 下也可以实现 C++ 的多线程，只不过有自己的一套代码，这里就不赘述了。
可以通过gcc -v查看自己的mingw gcc用的哪个接口：
Using built-in specs.
COLLECT_GCC=D:\Program Files (x86)\Dev-Cpp\TDM-GCC-64\bin\gcc.exe
COLLECT_LTO_WRAPPER=D:/Program\ Files\ (x86)/Dev-Cpp/TDM-GCC-64/bin/../libexec/gcc/x86_64-w64-mingw32/9.2.0/lto-wrapper.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-git-9.2.0/configure --build=x86_64-w64-mingw32 --enable-targets=all --enable-languages=ada,c,c++,fortran,lto,objc,obj-c++ --enable-libgomp --enable-lto --enable-graphite --enable-cxx-flags=-DWINPTHREAD_STATIC --disable-build-with-cxx --disable-build-poststage1-with-cxx --enable-libstdcxx-debug --enable-threads=posix --enable-version-specific-runtime-libs --enable-fully-dynamic-string --enable-libstdcxx-threads --enable-libstdcxx-time --with-gnu-ld --disable-werror --disable-nls --disable-win32-registry --enable-large-address-aware --disable-rpath --disable-symvers --prefix=/mingw64tdm --with-local-prefix=/mingw64tdm --with-pkgversion=tdm64-1 --with-bugurl=http://tdm-gcc.tdragon.net/bugs
Thread model: posix
gcc version 9.2.0 (tdm64-1)
（我这个其实比较拉胯，因为 MinGW 的官网下载太费劲了，就用 Dev C++ 包含的一个 TDM gcc）
不过看 MinGW 的官网，好像现在最新版本已经不支持 Win32 的接口了，只有 posix 的了。
r36 - 2022-01-19
Set the default _WIN32_WINNT to 0x0601 (Windows 7), r35 had it at Windows 10 due to mingw-w64 changes
Changed time_t to 64-bit on 32-bit Windows by default, matching MSVC (might require rebuilds of existing binaries)
POSIX thread model is now the default (and only) version
r35a - 2021-08-16
Using POSIX thread model with mingw-w64 winpthreads
std::thread
写一个最简单的 thread 的用法：
#include <thread>
#include <iostream>
using namespace std;
int main()
{
thread td1([]
{ cout << "hello world!1" << endl; });
thread td2([]
{ cout << "hello world!2" << endl; });
td1.join();
td2.join();
return 0;
}
thread 类最基本的用法就是接受一个函数作为参数，这里使用了 lambda 表达式。注意，线程是在thread对象被定义的时候开始执行的，而不是在调用join函数时才执行的，调用join函数只是阻塞等待线程结束并回收资源。
由于两个函数之间是并发执行，因此 th2 和 th1 之间打印的先后顺序是不固定的。
如果想在函数中传递参数，在 thread 的参数列表里传入函数的参数即可。
void print_num(int num)
{
for (int i = 0; i < num; i++)
{
cout << "Hello " << i << endl;
}
}
int main()
{
thread tds[10];
for (int j = 0; j < 10; j++)
tds[j] = thread(print_num, j);
for (int j = 0; j < 10; j++)
tds[j].join();
return 0;
}
这次的打印就不那么有序了，至少应该是一个金字塔形式的打印并没有做到。
join 和 detach
main 函数本身就是主线程，而调用 thread 相当于新开了一个线程执行操作，这就涉及到不同线程之间的同步问题了。
前面已经提过，join()意味着主线程需要阻塞来等待子线程结束，detach()则代表，子线程的控制权和主线程分离（分离的英文为 detach），主线程可以直接结束，不需要等待子线程。我们依然使用上面的代码，只不过把detach改为join
可以看到，主线程执行的速度非常快，三次运行都是子线程还未结束，主线程 main() 就已经结束了。不过不要担心，子线程依然会由系统调度在后台运行，主线程结束并不影响子线程。但这就引出了一个问题，一旦子线程调用了主线程中的某些资源，而主线程已经结束，子线程就会因为无法获取这些资源而崩溃。这部分我们以后会详细说明。
另外，需要注意两点：
-
不要对调用过 join/detach 的线程再次调用 join/detach。
此操作会导致程序终止。 -
不要在结束前不调用 join/detach。
线程的析构函数调用时会检查此线程有没有被调用过 join/detach，否则程序也会终止。因为如果不调用一个 joinable 线程的 join ，则该线程就会成为一个僵尸线程，一直留在内核中。
可以使用 joinable() 检查线程有没有被调用过 join/detach，所以正确的写法应该是如下：
for (int j = 0; j < 10; j++)
if(tds[j].joinable())
tds[j].detach();
参数传递
thread() 的源代码如下：
thread(_Callable&& __f, _Args&&... __args)
{
static_assert( __is_invocable<typename decay<_Callable>::type,
typename decay<_Args>::type...>::value,
"std::thread arguments must be invocable after conversion to rvalues"
);
#ifdef GTHR_ACTIVE_PROXY
// Create a reference to pthread_create, not just the gthr weak symbol.
auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
#else
auto __depend = nullptr;
#endif
_M_start_thread(_S_make_state(
__make_invoker(std::forward<_Callable>(__f),
std::forward<_Args>(__args)...)),
__depend);
}
可以看到，参数的传递使用的是右值引用（这里是C++17的折叠表达式），因此这样的函数参数是会编译失败的：
void print_num(int& num)
这涉及到多线程的设计思想，也就是尽可能只传递变量的副本进来，不希望子线程和主线程共享某些变量。但如果你就是想传引用呢？可以使用 std::ref 以引用方式传入，使用std::cref以 const 引用方式传入。
thread tds[10];
for (int j = 0; j < 10; j++)
tds[j] = thread(print_num, ref(j));
