c++多线程中detach的使用隐患

小灰灰 2022-11-29 05:44 166阅读 0赞

# 一、其他构造线程的方法 #

c++线程，除了可以利用普通函数创建线程外，还有其他创建线程的方法：

*  类对象
 *  Lambda表达式

具体使用方法如下：

#include <thread>
    
    using namespace std;
    
    class TA
    {
    public:
    	void operator ()()
    	{
    		printf("%s", "线程开始执行 \n");
    	}
    };
    
    void main()
    {
    	TA ta;
    	// thread 方法会调用TA的拷贝构造函数，所以使用detach方法，只要TA对象里没有引用和指针，就不会产生问题
    	thread mThreadObj(ta);
    	if (mThreadObj.joinable())
    		mThreadObj.join();
    
    	auto mLambdaThreaadObj = []
    	{
    		printf("%s", "线程开始执行 \n");
    	};
    
    	thread m_LambdaThread(mLambdaThreaadObj);
    	if (m_LambdaThread.joinable())
    		m_LambdaThread.join();
    }

补充内容：  
thread 方法会调用TA的拷贝构造函数，所以使用detach方法，只要TA对象里没有引用和指针，就不会产生问题，否则一旦传入主线程中的临时变量，并且主线程先于子线程执行完毕（可能会发生这种情况），那么程序运行情况就不可知，这是一定要避免的。

# 二、使用detach的隐患 #

首先，观察如下案例：

void mPrint(const int& i, char* pmBuff)
    {
    	printf("i : %d, buff: %s \n", i, pmBuff);
    }
    
    void main()
    {
    	int mI = 1;
    	int& mIy = mI;
    	char mBuff[]= "this is a test";
    
    	thread mThread(mPrint,mI, mBuff);
    	mThread.join();
    }

在mThread线程中，我传入了两个局部变量，并且接收函数中有两个参数，一个是引用类型，一个是指针类型。

如果我将线程的控制由join变为detach会引发什么问题？

很容易想到的是，因为主线程和子线程的结束时间不可控，所以局部变量的销毁时间不可控，那程序的运行情况就是未知的。再细究，这里由两个参数，是两个参数都会受影响，还是其中一个，又可能是哪一个？

因此，我将两者地址都进行了比较：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZpbmR5b3VsdWNreQ_size_16_color_FFFFFF_t_70]

可以看到，引用类型的参数内存地址和主线程中不一样，指针类型的参数和主线程中的一样。因此可以得到结论，**如果线程中的形参是引用类型，那主线程会将传入的值做一次赋值，所以不是真的直接引用绑定，但是如果形参是指针类型，那就不会拷贝**。

但如何避免这种情况呢？

我起初的思路是，只要再参数传递过程中，产生了拷贝那就是安全的（并不正确），因此我总结了c++中会调用拷贝构造函数的三种情形：

*  当类的一个对象去初始化该类的另一个对象时，注意是初始化不是赋值
 *  如果函数的形参是类的对象，调用函数参数是值传递；
 *  如果函数的返回值是类对象，函数调用完成返回时

这里适用的就是第二种情况。

但是，我又反应过来，这个拷贝构造函数发生的时间是在主线程之前还是之后呢？如果是在主线程结束之后才调用，那detach的风险并没有规避掉，因此我又做了如下尝试：

#include <thread>
    
    using namespace std;
    
    class TA
    {
    public:
    	int m_i;
    	TA(const int& i) :m_i(i)
    	{
    		printf("%s", "拷贝构造函数执行 \n");
    	};
    	void operator ()()
    	{
    		printf("%s", "线程开始执行 \n");
    	}
    };
    
    void mPrint( char* pmBuff,const TA&ta)
    {
    	printf("i : %d, buff: %s \n",ta.m_i, pmBuff);
    }
    
    void main()
    {
    	int mI = 1;
    	int& mIy = mI;
    	char mBuff[]= "this is a test";
    
    	//利用类型转化构造函数将整型转成TA类型
    	thread mThread(mPrint, mBuff,mI);
    	mThread.detach();
    }

因为thread肯定会调用传入对象的拷贝构造函数，所以如果输出中没有显示拷贝构造函数的执行，那么就说明，拷贝可能发生在主线程结束之后。  
执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZpbmR5b3VsdWNreQ_size_16_color_FFFFFF_t_70 1]  
结论：  
这样也是不安全的。

那究竟如何解决detach的这个隐患呢？

通过翻阅资料发现，只需使用临时对象即可完美规避这个问题。  
如下所示：

thread mThread(mPrint, mBuff,TA(mI));

# 三、结论 #

1、如果传递简单类型参数，使用值传递，不要使用引用传递，杜绝使用指针传递；  
2、如果传递类对象，在创建线程时就构造临时对象，在函数参数里，使用引用来接 。

（建议一律使用join，能避免90%的问题）

以上就是本篇文章的全部内容，如果不足，请批评指正。

**本文转载自**：[深入理解c++多线程：（一）detach使用隐患][c_detach]

**参考文章**：[C++ thread detach的大坑][C_ thread detach]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZpbmR5b3VsdWNreQ_size_16_color_FFFFFF_t_70]: /images/20221124/705f8c0252d9474da851d212fd225a32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZpbmR5b3VsdWNreQ_size_16_color_FFFFFF_t_70 1]: /images/20221124/a51a0c48ed0248ac9739262afb9c24f6.png
[c_detach]: https://blog.csdn.net/Findyoulucky/article/details/104599956?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-2.channel_param
[C_ thread detach]: https://blog.csdn.net/xuebing1995/article/details/103728570