【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 
#include 

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;
}

这次的打印就不那么有序了,至少应该是一个金字塔形式的打印并没有做到。
【C++】多线程(一):std::thread的使用_第1张图片

join 和 detach

main 函数本身就是主线程,而调用 thread 相当于新开了一个线程执行操作,这就涉及到不同线程之间的同步问题了。

前面已经提过,join()意味着主线程需要阻塞来等待子线程结束detach()则代表,子线程的控制权和主线程分离(分离的英文为 detach),主线程可以直接结束,不需要等待子线程。我们依然使用上面的代码,只不过把detach改为join
【C++】多线程(一):std::thread的使用_第2张图片
可以看到,主线程执行的速度非常快,三次运行都是子线程还未结束,主线程 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));

你可能感兴趣的:(C++,工作业务,c++,开发语言)