【C++】多线程编程二（std::thread详解）

std::thread详解

（1）启动线程

①无参无返回的函数作为入参

②函数对象（仿函数）作为入参

（2）不等待线程detch()

（3）等待线程完成join()

（4）向线程函数传递参数

（5）转移线程所有权

（6）标识线程id

std::thread详解

每个程序至少有一个线程：执行main()函数的线程，其余线程有其各自的入口函数。线程与原始线程（以main()函数为入口函数的线程）同时运行。如同main()函数执行完退出一样，当线程执行完入口函数后，线程也会退出。在为一个线程创建了一个 std::thread 对象后，需要等待这个线程结束。

（1）启动线程

线程在 std::thread 对象创建（为线程创建指定任务）时启动。使用C++线程库启动线程就是构造 std::thread 对象。使用时需要引入头文件 <thread> 。

std::thread 构造函数：

构造函数	语法格式	备注
默认构造函数	thread() noexcept;	创建一个空的std::thread 对象
初始化构造函数	template <class Fn, class... Args> explicit thread(Fn&& fn, Args&&... args);	创建一个std::thread 对象该对象可以被joinable，新产生的线程会调用fn函数，该函数的参数由 args 给出。
拷贝构造函数[delete]	thread(const thread&) = delete;	禁用，std::thread 对象不可拷贝构造
移动构造函数	thread(thread&& x) noexcept;	调用成功之后，x就不代表任何thread对象了

①无参无返回的函数作为入参

#include <thread>void do_work();
std::thread mythread(do_work);

do_work()函数在其所属的线程上允许，直到函数执行完毕，线程也就结束了。

②函数对象（仿函数）作为入参

#include <iostream>
#include <thread>
using namespace std;class Test
{
public:void operator()()const{cout << "hello world" << endl;}
};int main()
{//Lambda表达式创建的匿名函数对象thread mythread([] {cout << "hello world" << endl; });//1和2都是函数对象//thread testthread((Test())); //1thread testthread{ Test() };//2 新统一的函数对象初始化语法mythread.join();testthread.join();
}

启动线程后，需要明确是等待线程结束(join)还是让其自主运行(deatch)。

必须在 std::thread 对象销毁之前做出决定，否则程序就会终止（ std::thread 的析构函数函数会调用 std::terminate(),这时再决定会触发相应的异常）。

detach方式，启动的线程自主在后台运行，当前的代码继续往下执行，不等待新线程结束。
join方式，等待启动的线程完成，才会继续往下执行。

（2）不等待线程detch()

detach()线程：将当前线程对象所代表的执行实例与该线程对象分离，使得线程的执行可以单独进行。一旦线程执行完毕，它所分配的资源将会被释放。

调用 detach 函数之后：

*this 不再代表任何的线程执行实例。
joinable() == false
get_id() == std::thread::id()

另外，如果出错或者 joinable() == false，则会抛出 std::system_error。

示例演示：

void thread01()
{for (int i = 0; i < 5; i++){cout << "Thread 01 is working ！" << endl;Sleep(10);}
}
void thread02()
{for (int i = 0; i < 5; i++){cout << "Thread 02 is working ！" << endl;Sleep(20);}
}int main()
{thread task01(thread01);thread task02(thread02);task01.detach();task02.detach();for (int i = 0; i < 5; i++){cout << "Main thread is working ！" << endl;Sleep(20);}

由上图主线程结果和子线程结果无规则输出可知，detach方式主线程和子线程是自主运行的，互不干扰。

如果不等待线程，就必须保证线程结束之前，可访问的数据的有效性。例如：对象销毁之后再去访问，就会产生未定义的错误。这种情况很可能发生再线程还没结束，函数已经退出的时候，这时线程函数还持有函数局部变量的指针或引用。

class func
{
public:int& i;func(int& i_) : i(i_) {}void operator() (){for (unsigned j = 0; j < 1000000; ++j){do_something(i);           // 1 潜在访问隐患：悬空引用}}
};void oops()
{int some_local_state = 0;func my_func(some_local_state);std::thread my_thread(my_func);my_thread.detach();          // 2 不等待线程结束
}                               // 3 新线程可能还在运行//如果线程还行运行，就会调用do_something（i）函数，就会访问一个已经销毁的变量。

解决方案：将数据复制到线程中，而非复制到共享数据中。

也可以通过join()函数来确保线程在函数完成前结束。

（3）等待线程完成join()

如果需要等待线程，可以使用join()函数。 my_thread.detach()改为my_thread.join() 就可以确保局部变量在线程完成后才销毁。调用join()的行为，还清理了线程相关的存储部分，这样 thread 对象将不再与已经完成的线程有关联。这意味着，只能对一个线程使用一次join();一旦使用过join()，thread 对象就不能再次join()，当对其使用joinable()时，将返回false。

示例演示:

void thread01()
{for (int i = 0; i < 5; i++){cout << "Thread 01 is working ！" << endl;Sleep(10);}
}
void thread02()
{for (int i = 0; i < 5; i++){cout << "Thread 02 is working ！" << endl;Sleep(20);}
}int main()
{thread task01(thread01);thread task02(thread02);task01.join();task02.join();for (int i = 0; i < 5; i++){cout << "Main thread is working ！" << endl;Sleep(20);}}

由上图主线程结果都在子线程结果后面输出可知，join使得调用thread01()和thread02()的线程task01和task02发生阻塞，直到由阻塞的线程执行完毕后，主线程才执行。

joinable(): 检查线程是否可被 join。检查当前的线程对象是否表示了一个活动的执行线程，由默认构造函数创建的线程是不能被 join 的。另外，如果某个线程已经执行完任务，但是没有被 join 的话，该线程依然会被认为是一个活动的执行线程，因此也是可以被 join 的。

【小结】

如果想要分离一个线程，可以在线程启动后，直接使用detach() 进行分离。

如果打算等待对应的线程，则需要挑选join()的位置。当在线程运行之后产生异常，在join()调用之前抛出，就意味着这次调用会被跳过。

（4）向线程函数传递参数

创建std::thread 对象时，向构造函数中的可调用对象或函数传递参数，和普通的函数差不多，对应函数参数顺序依次传入即可。

【注意】默认参数是以引用的形式拷贝到线程独立内存中。

#include <iostream>
#include <thread>void func1(int a)
{a = 100;cout << "func1:" << a << endl;
}void func2(int& a)
{a = 100;cout <<"func2:"<< a << endl;
}int main()
{int a = 10;std::thread t1(func1, a);//++++++++ 1 编译成功
//通过初始化构造函数，创建了一个std::thread对象t1，新产生的进程会调用func1,该函数的参数为at1.join();cout <<"Main:"<< a << endl;//std::thread t2(func2, a);//++++++++2 编译失败std::thread t2(func2, std::ref(a));//++++++3  编译成功t2.join();cout <<"Main:" << a << endl;a++;std::thread t3(func2, std::ref(a));std::thread t4(std::move(t3));//++++++++++4  编译成功t4.join();cout << "Main:" << a << endl;}

①中使用std::thread 构造函数创建对象t1时，参数a是以拷贝进行值传递的，所以子进程对a的修改，只对子进程独立内存中的a起作用，并不影响主进程的a。

func2 期待传入一个引用参数，但是std::thread 的构造函数2并不知晓；构造函数无视函数期待的参数类型，并盲目的拷贝已提供的变量。代码将参数以右值的方式进行拷贝传递，并被函数func2调用。因为函数期待是一个非常量引用作为参数，而非一个右值作为参数，所以编译时出错。

解决方案：使用 std::ref 将参数转换成引用的形式。如3所示即可。

③中参数是引用方式传递，相当于子进程和主进程共享参数a,所以子进程对参数a的修改，同样影响了主进程的a.

④中使用移动构造函数将t3对象的资源移动给t4,t3不再是thread对象，不起作用了，func2在线程对象t4正常运行，并由于是引用传递，所以也更改了主线程a的值。

（5）转移线程所有权

上面示例4中运用到了一个移动 std::move操作。C++标准库中有许多资源占有类型，比如 std::ifstream ,std::unique_ptr和std::thread 都是可移动的，但不可拷贝。当要写一个后台启动线程的函数，并想通过新线程返回的所有权去调用这个函数，而不是等待线程结束再去掉用。

void some_function();
void some_other_function();
std::thread t1(some_function);            // 1
std::thread t2=std::move(t1);            // 2
t1=std::thread(some_other_function);    // 3

新线程开始与t1相关联①。当显式使用std::move创建t2后②，t1的所有权就转移给了t2。之后，t1和执行线程已经没有关联了，执行some_function的函数线程与t2关联。

然后，一个临时std::thread 对象相关的线程启动了③。为什么不显式调用std::move()转移所有权呢？因为，所有者是一个临时对象——移动操作将会隐式的调用。

std::thread 赋值操作：

函数名称	函数原型	备注
移动赋值	thread& operator=(thread&& rhs) noexcept;	移动赋值，如果当前对象不可joinable，需要传递一个右值引用给move赋值操作；如果当前对象可被joinable，则会调用terminate()报错。
拷贝赋值	thread& operator=(const thread&) = delete;	被禁用，所以std::thread对象不可拷贝

std::thread t3;                            // 4
t3=std::move(t2);                        // 5
t1=std::move(t3);                        // 6 赋值操作将使程序崩溃

t3使用默认构造方式创建④，与任何执行线程都没有关联。调用 std::move()将与t2关联线程的所有权转移到t3中⑤。因为t2是一个命名对象，需要显式的调用std::move()。移动操作 #5 完成后，t1与执行some_other_function的线程相关联，t2与任何线程都无关联，t3与执行some_function的线程相关联。

最后一个移动操作，将some_function线程的所有权转移⑥给t1。不过，t1已经有了一个关联的线程(执行some_other_function的线程)，所以这里系统直接调用std::terminate()终止程序继续运行。这样做（不抛出异常，std::terminate()是noexcept函数)是为了保证与std::thread的析构函数的行为一致(说明：不能通过赋一个新值给std::thread对象的方式来”丢弃”一个线程)。

线程的所有权转移场景：

①函数返回std::thread 对象（所有权在函数外进行转移）

void do_task()
{cout << "do_task" << endl;
}
std::thread function()
{void do_task();return std::thread(do_task);
}int main()
{std::thread task01 = function();task01.join();cout << "main end" << endl;
}

②std::thread 对象作为参数（所有权在函数内部传递）

void do_task()
{cout << "do_task" << endl;
}void function(std::thread t)
{t.join();
}int main()
{std::thread t(do_task);function(std::move(t));cout << "main end" << endl;
}

（6）标识线程id

线程标识类型为 std::thread::id ,可以通过两种方式进行检索。

一是，通过调用std::thread对象的成员函数 get_id () 来直接获取。如果std::thread对象没有与任何线程相关联，get_id()将返回std::thread::type 默认值，这个值表示“无线程”。

二是，当前线程中调用 std::this_thread::get_id() ,这个函数定义在<thread>头文件中，也可以获得线程标识。

std::thread::id对象可以自由拷贝和对比，因为标识符可以复用。

如果两个对象的id相等，那么它们是同一个线程，或都是“无线程”。如果不等，那就代表两个不同线程，或一个有线程，另一个没有线程。

void do_master_task() {cout << "do master task" << endl;
}void do_other_task() {cout << "do other task" << endl;
}int main()
{std::thread::id master_id = std::this_thread::get_id();thread mythread([] {cout << "open child thread" << endl; });mythread.join();if (std::this_thread::get_id() == master_id){do_master_task();}else {do_other_task();}
}