【C++】多线程（一）：std::thread的使用

这篇文章应我朋友的邀请，写一篇文章介绍下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() 就已经结束了。不过不要担心，子线程依然会由系统调度在后台运行，主线程结束并不影响子线程。但这就引出了一个问题，一旦子线程调用了主线程中的某些资源，而主线程已经结束，子线程就会因为无法获取这些资源而崩溃。这部分我们以后会详细说明。

另外，需要注意两点：

1. 不要对调用过 join/detach 的线程再次调用 join/detach。
   此操作会导致程序终止。

2. 不要在结束前不调用 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));