❥关于C++之多线程┆＜thread＞join()detach()

Posted 2022-03-21 itzyjr

std::thread (C++11)
class thread;

描述：thread类来表示执行的各个线程。

执行线程是一个指令序列，可以在多线程环境中与其他此类序列并行执行，同时共享相同的地址空间。
➊初始化的thread对象表示活动的执行线程；这样的线程对象是可接合的，并且具有唯一的thread id。
➋默认构造(未初始化)的thread对象是不可接合的，其thread id对于所有不可接合的线程都是公共通用的。
➌如果从中移动，或者调用了接合(join)或分离(detach)，则可接合线程将变得不可接合。

构造函数：构造一个thread对象。

default (1)	thread() noexcept;
initialization (2)	template <class Fn, class... Args>
                    explicit thread (Fn&& fn, Args&&... args);
copy [deleted] (3)	thread (const thread&) = delete;
move (4) thread (thread&& x) noexcept;
——————————————————————————————————————————————————————————————
（1） 默认构造函数
构造一个不代表任何执行线程的线程对象。
（2） 初始化构造函数
构造一个线程对象，该对象表示一个新的可接合执行线程。
新的执行线程调用fn，将参数作为参数传递（使用其左值或右值引用的衰减副本）。
这个构造的完成与fn副本调用的开始同步。
（3） 复制构造函数
已删除构造函数表单（无法复制线程对象）。
（4） 移动构造函数
构造一个线程对象，该对象获取由x（如果有的话）表示的执行线程。
此操作不会以任何方式影响移动线程的执行，它只是传输其处理程序。
x对象不再代表任何执行线程。
————————————————————————————————————————————————————————————————
参数：
fn
指向函数的指针、指向成员的指针或任何类型的可移动可构造函数对象（即，其类定义运算符()的对象，包括闭包和函数对象）。
返回值（如果有）将被忽略。
——————————————————————
args...
传递给fn调用的参数（如果有）。其类型应为可移动式。
如果fn是成员指针，则第一个参数应为定义该成员的对象（或引用，或指向该成员的指针）。
——————————————————————
x
thread对象，其状态被移动到构造的对象。

Fn和Arg...是模板参数：如果隐式推断，则这些是将参数绑定到的适当的左值或右值引用类型。但是请注意，在新线程中调用fn时，fn和args...的衰变副本始终使用。

>>> 可接合的thread对象，在它被销毁之前，应该是joined或detached。

thread创建后，需要在调用线程中需要指明是join还是detach，否则会发生错误。<<< 

join()与detach()：

void join(); 接合线程。

当线程执行完成时，函数返回。
这将使该函数返回的时刻与线程中所有操作的完成同步：这将阻止调用该函数的线程的执行，直到构造时调用的函数返回（如果尚未返回）。
调用此函数后，线程对象将变得不可接合，并且可以安全地销毁。

void detach(); 分离线程。

将对象表示的线程与调用线程分离，允许它们彼此独立执行。
这两个线程都会继续，不会以任何方式阻塞或同步。请注意，当其中一个结束执行时，其资源将被释放。
调用此函数后，线程对象将变得不可接合，并且可以安全地销毁。

示例——join()：

#include <iostream>
#include <thread>
using namespace std;
void func(int n) 
	for (int i = 0; i < n; i++) 
		cout << "子线程 func():" << i << endl;
	

int main()  // 主线程
	cout << "mian() start" << endl;
	thread t(func, 5);// 子线程
	t.join();// 等待子线程结束后才进入主线程
	cout << "mian() end" << endl;
	return 0;

mian() start
子线程 func():0
子线程 func():1
子线程 func():2
子线程 func():3
子线程 func():4
mian() end

示例——detach()： 

#include <iostream>
#include <thread>
using namespace std;
void func(int n) 
	for (int i = 0; i < n; i++) 
		cout << "子线程 func():" << i << endl;
	

int main()  // 主线程
	cout << "mian() start" << endl;
	thread t(func, 5);// 子线程
	t.detach();// 子线程与主线程彼此独立执行
    for (int i = 0; i < 20; i++)
    	cout << "mian() end" << endl;
	return 0;

mian() start
mian() end
mian() end
mian() end
mian() end子线程 func():
mian() end
mian() end
mian() end
mian() end
mian() end
mian() end
0mian() end
mian() end

mian() end
子线程 func():mian() end1

mian() end子线程 func():
mian() end2

子线程 func():mian() end3

子线程 func():mian() end4

mian() end
mian() end

示例——thread::get_id&this_thread::get_id

#include <iostream>// std::cout
#include <thread>// std::thread, std::thread::id, std::this_thread::get_id
std::thread::id main_thread_id = std::this_thread::get_id();
void checkThreadType() 
	if (main_thread_id == std::this_thread::get_id())
		std::cout << "This is the main thread.\\n";
	else
		std::cout << "This is not the main thread.\\n";

int main() 
	checkThreadType();// 主线程中执行函数
	std::thread th(checkThreadType);// 子线程中执行函数
	th.join();// block main thread直到构造函数调用的函数运行结束
	return 0;

This is not the main thread.
This is the main thread.

 示例——joinable()：

// example for thread::joinable
#include <iostream>// std::cout
#include <thread>// std::thread
void mythread() 
	// do stuff...

int main() 
	std::thread foo;
	std::thread bar(mythread);
	std::cout << "Joinable after construction:\\n" << std::boolalpha;
	std::cout << "foo: " << foo.joinable() << '\\n';
	std::cout << "bar: " << bar.joinable() << '\\n';
	if (foo.joinable()) foo.join();
	if (bar.joinable()) bar.join();
	std::cout << "Joinable after joining:\\n" << std::boolalpha;
	std::cout << "foo: " << foo.joinable() << '\\n';
	std::cout << "bar: " << bar.joinable() << '\\n';
	return 0;

Joinable after construction:
foo: false
bar: true
Joinable after joining:
foo: false
bar: false