标准写法:
#include<iostream> #include<thread> using namespace std; void MyThread() { cout << "MyThread线程1开始了" << endl; cout << ".................." << endl; cout << "MyThread线程1结束了" << endl; } int main() { thread my(MyThread); my.join(); cout<<"主线程开始了"<< endl; cout<<"............."<< endl; cout<<"主线程结束了"<< endl; return 0; }
输出结果:
分析:
首先利用可调用对象MyThread创建了子线程my;
然后调用类thread的函数join,表示只有当我的子线程结束了,主线程才可以结束;说白了它的作用就是用来堵塞主线程的.
如果不加join函数，那么主进程和子进程就会同时执行，不分先后，如果子线程还没结束主线程就结束了，那么系统会抛出异常，如下代码:
#include<iostream> #include<thread> using namespace std; void MyThread() { cout << "MyThread线程1开始了" << endl; cout << ".................." << endl; cout << "MyThread线程1结束了" << endl; } int main() { thread my(MyThread); //my.join(); cout<<"主线程开始了"<< endl; cout<<"............."<< endl; cout<<"主线程结束了"<< endl; return 0; }
输出:
如果我就想让主线程先退出，但是不抛出异常，那么可以用detach()，如下代码：
#include<iostream> #include<thread> using namespace std; void MyThread() { cout << "MyThread线程1开始了" << endl; cout << ".................." << endl; cout << "MyThread线程1结束了" << endl; } int main() { thread my(MyThread); my.detach(); cout<<"主线程开始了"<< endl; cout<<"............."<< endl; cout<<"主线程结束了"<< endl; return 0; }
输出:
对于使用detach(),存在许多隐患，比如：
#include<iostream> #include<thread> using namespace std; class MyThread { public: int &x; MyThread(int &_x):x(_x) {} void operator()() { cout << "子线程开始执行了" << endl; cout << "x的值是:" << x << endl; cout << "..............." << endl; cout << "子线程结束了" << endl; } }; int main() { int data = 1;
MyThread myobj(data); thread my(myobj); my.detach(); cout<<"主线程开始了"<< endl; cout<<"............."<< endl; cout<<"主线程结束了"<< endl; return 0; }
输出:
分析:
1.这里造成的原因主要就是因为我的类中含有引用，对于刚开始用int data=1生成的变量，main结束后（主线程结束），data就会消失，由于我使用了detach，所以主线程和子线程谁先谁后结束不确定，如果主线程先结束了，data也会跟着消失，子线程再去访问该数据便会无从寻起。
基于此，可能连带产生如下困惑，如下两行代码：
MyThread myobj(data);。。。。。。。。。。。。①
thread my(myobj); .。。。。。。。。。。。。。。②
如果主线程先结束，那么myobj对象一同消失，那么②的代码中的myobj不也会消失吗?
为了解答这个问题，做如下实验:
#include<iostream> #include<thread> using namespace std; class MyThread { public: int &x; MyThread(int &_x):x(_x) {} MyThread(const MyThread& another):x(another.x) { cout << "拷贝构造函数被执行" << endl; } ~MyThread() { cout << "析构函数被执行" << endl; } void operator()() { cout << "子线程开始执行了" << endl; cout << "x的值是:" << x << endl; cout << "..............." << endl; cout << "子线程结束了" << endl; } }; int main() { int data = 1; MyThread myobj(data); thread my(myobj); my.detach(); cout<<"主线程开始了"<< endl; cout<<"............."<< endl; cout<<"主线程结束了"<< endl; return 0; }
输出:
以上代码只有thread my(myobj); 这一句才有可能发生拷贝构造.
所以对于：
MyThread myobj(data);。。。。。。。。。。。。①
thread my(myobj); .。。。。。。。。。。。。。。②
①到②会发生拷贝构造，图的运行结果就是证明。
如果join或者detach其中一个已被使用，那么就不能再次被使用，
类库提供了一个joinable函数可以判断是否已被使用，看如下代码：
1 #include<iostream> 2 #include<thread> 3 using namespace std; 4 class MyThread 5 { 6 public: 7 int &x; 8 MyThread(int &_x):x(_x) {} 9 MyThread(const MyThread& another):x(another.x) 10 { 11 12 cout << "拷贝构造函数被执行" << endl; 13 } 14 ~MyThread() 15 { 16 cout << "析构函数被执行" << endl; 17 } 18 void operator()() 19 { 20 21 cout << "子线程开始执行了" << endl; 22 cout << "x的值是:" << x << endl; 23 cout << "..............." << endl; 24 cout << "子线程结束了" << endl; 25 } 26 }; 27 28 int main() 29 { 30 int data = 1; 31 MyThread myobj(data); 32 thread my(myobj); 33 my.join(); 。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。① 34 if (my.joinable()) 35 { 36 cout << "join或者detach可以被使用" << endl; 37 } 38 else 39 { 40 cout << "join或者detach已经被用" << endl; 41 } 42 my.detach();。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。② 43 if (my.joinable()) 44 { 45 cout << "join或者detach可以被使用" << endl; 46 } 47 else 48 { 49 cout << "join或者detach已经被用" << endl; 50 } 51 cout<<"主线程开始了"<< endl; 52 cout << "..............." << endl; 53 cout << "主线程结束了" << endl; 54 55 return 0; 56 }
对①和②插入断点进行调试：
第一次进入了if语句，继续调试：
当执行第二个时候发生了异常。
继续实验：
更加证实了前面的观点，join或者detach两者只能使用其中的一个，并且只能一次。