c++11多线程—多线程的创建和detach

最新推荐文章于 2024-06-14 10:34:50 发布

syao_zj

最新推荐文章于 2024-06-14 10:34:50 发布

阅读量929

点赞数 1

分类专栏：笔记 c++ 文章标签：多线程 c++11

本文链接：https://blog.csdn.net/syao_zj/article/details/106040330

版权

c++ 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

笔记

1 篇文章 0 订阅

订阅专栏

TOC在c++11中用多种方法创建一个线程，并引出一些注意事项，文章篇幅较紧凑，且包含有基础知识和一些开发过程中可能遇到的问题，可根据需要，选择性浏览。

一、简单介绍

首先介绍两个概念：
先做个假设，我一边玩游戏，一边听歌；
并行： 我的电脑是多cpu的，其中一个cpu处理游戏的信息，另一个处理听歌软件信息，此时这两个进程在我的电脑上是同时执行的。
并发： 我的电脑只有一个cpu，但cpu性能很好，往往一个游戏当前的数据处理完之后，cpu还剩下很多时间；为了提高cpu的利用率，把他分配给听歌软件，当游戏需要cpu时，再把cpu还给它。就这样cpu以极快的速度不断切换所有权，造成了伪并行的现象。

为何多线程：
·避免阻塞，传统的进程中，只有一个主线程（main），若程序的某个位置出现了较长时间等待，那么整个程序将在这阻塞，极端一点的例子，等待用户输入信息。
·提升性能（不包括所有情况），举个栗子，程序要做两件事：1，计算a+b的值，2，把计算结果打印出去，传统的单线程需要一步步进行1-2这样，多线程可以把同时做两件事，在数量较大的时候，性能获得到很大提升
·在windows操作系统下，cpu在线程之间的切换的消耗，比进程之间切换的资源消耗要小得多，进程之间切换涉及到内存等资源的分配，cpu的调度等等。
·线程之间的通信要比进层之间的消耗小的多，子线程之间是共享内存空间的，虽然这带来的另一个问题，以后再讲。
最后，每个线程都有一个主进程，若主线程结束，则该进程结束。（后面会用到这个概念）

二、创建线程的几种方法：

c++11中引入了新的头文件thread，使用时#include<thread>即可，下面我会用尽量简要的代码说明。

1.用函数创建

直接看代码：

#include<iostream>
#include<thread>
using namespace std;

//函数的参数是多样的，对象，智能指针，引用等等都可以
void t_print(const int & i)
{
  cout<<"i="<< i <<endl;
}

int main()
{
int a=12;
//创建一个线程，参数列表依次由：函数名，函数参数1，参数2 ......决定
thread th1(t_print,a);  
th1.join();
//th1.detach();
return 0;
}

前面说到，主线程结束，则该进程结束。
th1.join()：主线程在此等待，直到线程th1执行结束，然后th1线程join()进来，主线程才结束，ok
th1.datach():也能正常执行，但是有点区别，此时该线程被detach出去了，不归主线程管，该线程切换到后台执行，并在其执行完毕之后，交给守护线程进行资源的释放。
问题：我们都知道局部变量在栈空间，此例中线程传递的是main中局部变量a的引用。假设，detach出去之后线程th1执行的很慢，主线程结束，a的空间被回收，此时th1线程仍在后台运行，并且访问了被销毁的内存a，是否会出现异常。（后面有篇幅特意说这个3.1）

2.lambda表达式

#include<iostream>
#include<thread>
using namespace std;

int main()
{
auto lamb= []{cout<<"i am thread!"<<endl; };

thread th2(lamb);
th2.join();

return 0;
}

3.类的操作符重载

看代码：

#include<iostream>
#include<thread>
using namespace std;
class A
{
public:
 void message()
 {
  cout << "i am a message!" << endl;
 }
 //重载（）运算符
 void operator()(void)
 {
  message();
  //func2 ...... 可以进行很多数据的处理
 }
};

int main()
{
 A a;
 thread th3(a);
 th3.join();
 return 0;
}

4.类成员函数创建线程

看代码：

#include<iostream>
#include<string>
#include<thread>
using namespace std;
class A
{
public:
 void message(string tmp)
 {
  cout << tmp << endl;
 }
};
int main()
{
 A a;
 thread th4( &A::message, &a ,"hello thread!");
 th4.join();
 return 0;
}

三、detached中会遇的问题

1.detach后，子线程使用了被销毁的空间吗

前面提到了这个问题（2.2节），子线程很慢，在线程结束，并且释放data和p_data的空间之后，还在执行，先来看一段代码：

#include<iostream>
#include<thread>
using namespace std；

void show(const int& data, int *p)
{
 //cout << "in thread show" << endl;
 cout << "data=" << data <<"\t"<<"data 的地址为："<<&data<< endl;;
 cout << "*p=" << *p <<"\t"<<"p的值为:"<<p<< endl;
}
void main_show(void)
{
//让主进程慢一点结束
 cout << "i am  main thread" << endl;
 cout << "i am  main thread" << endl;
 cout << "i am  main thread" << endl;
 cout << "i am  main thread" << endl;
 cout << "i am  main thread" << endl;
}
int main()
{
 int data = 12, p_data = 3;
 cout << "int main: data的地址为:" << &data << endl;
 cout << "int main: p_data的地址为:" << &p_data << endl;
  
 thread th5(show, data, &p_data);
 th5.detach();

 main_show();
 return 0;
}

在这里插入图片描述
此时刚好时*p的打印还没执行结束，主线程就结束了，执行结果可以看出，虽然函数的参数传递了引用，但是在main中和在线程5中，data的地址是不一致的，这说明子线程创建时，对传递的data值进行了拷贝，并没有按预期的传递一个引用。
在看一个执行结果：
在这里插入图片描述
从该结果可以看出，传递指针变量的时候，地址是一致的，也就是说，该子线程在主线程结束，并释放p_data的资源之后，仍然有可能在后台，访问非法的p_data的地址。这是很危险的！

2.创建线程时，何时进行的拷贝

分析了1中的情况，得知创建线程时，为了安全起见，编译器会做一次拷贝，那么会不会存在这种情况：当主线程已经执行完了，但是拷贝还没完成，导致子线程创建需要拷贝的时候，访问了主线程已经释放的内存；
看代码：

#include<iostream>
#include<thread>
using namespace std;
class A
{
private:
 mutable int data;
public:
 A(int dat=0):data(dat)
 {
  cout << " id_number= " << this_thread::get_id()<< "the calling of constructor A!" << endl;
 }
 A( const A & t) 
 {
  data = t.data;
  cout << " id_number= " << this_thread::get_id()<< "the calling of copy consturctor" << endl;
 }
 void message()const
 {
  cout <<data<< endl;
 }
};
void pt_main(void)
{
 //让主线程多执行一会儿
 cout << "csharppythonc++" << endl;
 cout << "csharppythonc++" << endl;
 cout << "csharppythonc++" << endl;
 cout << "csharppythonc++" << endl;
 cout << "csharppythonc++" << endl;
}
void test1(const A & t) 
{
 cout << "in test1 : id_number= " << this_thread::get_id() << endl;//子线程id
 t.message();
}
int main()
{
 cout << "in main : id_number= " << this_thread::get_id() << endl; //主线程id
//test1
 thread th5(test1,A(23));  //此时在主线程中调用了构造函数
 
 //test2
//thread th5(test1,23);

 th5.detach();
 pt_main(); 
 return 0;
}

执行test1的结果如下：
在这里插入图片描述
结果可以看出，对象的构造和拷贝构造（证明了确实进行了拷贝构造，即使传递的是引用）执行的线程id和主线程id是一致的，而此时主线程完成了构造和拷贝构造。

再看看test2，此处是隐式转换，传递此参数，编译器会隐式的把int转换为A类型的对象。结果如下：
在这里插入图片描述
根据结果可以看出，此时的构造函数的id是19492，main是18444，此时构造是在子线程中进行的，拷贝构造的打印没出来，主线程就结束了，说明主线程只是传递给了子线程一个参数，然后子线程自己调用构造函数来进行构造。
对于这个问题的个人理解：
构造线程分为两部分：
1.主线程把参数传递过去，函数中体现为thread th5();语句的结束，分号之前的操作，由主线程来进行，一旦分号结束，剩下的任何操作，都由子线程自己进行。test2中，主线程只传递了值23，分号结束，剩下的构造就交给子线程自己了。
2.子线程收到参数，进行剩下的操作。