C++11并发与多线程(3)-detach()大坑

最新推荐文章于 2023-04-27 21:38:11 发布
最新推荐文章于 2023-04-27 21:38:11 发布
阅读量868 收藏 2
点赞数 2
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44314245/article/details/111606813
版权

文章目录

detach大坑

1、传递临时对象作为线程参数

在上篇文章中，我们简单介绍了使用仿函数构建线程时，不能使用引用、指针等来初始化类，防止在detach()时，主线程把局部变量内存释放，本节来详细介绍下，除仿函数对象外，在使用detach()还要注意哪些bug。

1.1、子线程入口函数的参数地址问题

#include <iostream>
#include <thread>
#include <string>

using namespace std;

/*void myPrint(const int& i, const char* name){

	// 如果线程从主线程detach了
	// 在子线程的函数入口处，使用引用来传递参数，但是该引用不是真正的引用，不再是地址传递，实际上为值传递，重新拷贝一个值并重新申请一块内存给了子线程。
    // 即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
	// 推荐改为const int i
	cout << "id is: " << i << endl;

	// 与引用不同，使用指针来传递参数，该指针仍然指向的主线程中申请的地址，
    // 也就是说name还是指向原来的字符串，那么，当主线程中的的局部变量被释放，子线程对应的内存也就不安全了
	cout << "my name is: " << name << endl;
}*/

// 故而推荐的写法就是：不推荐使用引用，并且绝对不能使用指针
// 那么如何传递变量和字符串呢？必须添加const
void myPrint(const int i, const string& name){ 

    cout << "id is: " << i << endl;
    cout << "my name is: " << name << endl;

}

int main(int argc, char* argv[]){

    thread myThreaad(myPrint, 1006, "twlcy");

    myThreaad.detach();

    cout << "I love China!" << endl;

    return 0;
}

通过上述的代码的展示，我们把避免了引用和指针问题带来的内存回收问题：
1、对于整型、浮点型等使用引用，在子线程中实际是值传递，不再是地址传递，这使得线程运行比较安全，但是，避开引用，会更加安全；
2、对于字符串，使用指针，会导致传递的参数的指针指向主线程中局部变量的地址，那么我们就利用string类型的引用来代替指针(当然最好也就不使用引用)，使得线程相对安全。

1.2、数据类型隐式转换问题

也就是说上述解决方式相对安全，但是对于char类型隐式地转换为string，仍存在一些问题。就是说存在一定地可能性使得char类型数据被主线程释放掉了，那么又怎么使用该数据转为string类型，这就会导致程序出现bug。

解决方式：只要用临时构造的类对象作为参数传递给线程，那么就一定能够在主线程执行完毕前把线程函数的第二个参数构建出来，从而确保即便detach()了，子线程也能安全运行。

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

void myPrint(const int i, const string& name) 
{
	cout << i << endl;
	cout << name << endl;
}

int main(int argc, char* argv[])
{
	int mvar = 1;
	char mybuf[] = "this is a test";
	
	//推荐先创建一个string地临时对象就绝对安全了。。。。
	thread myThread(myPrint, mvar, string(mybuf))
	myThread.detach();

	cout << "I love China!" << endl;
}

这里证明一下上述结论：
也就是创建了一个类，并且进行创建

#include <iostream>
#include <thread>
#include <string>

using namespace std;

class Student{

public:
    Student(int id):m_Id(id){
        cout << "Constructor is running!" << endl;
    }
    Student(const Student& stu):m_Id(stu.m_Id){
        cout << "Copy-constructor is running!" << endl;
    }
    ~Student(){
        cout << "Destructor is running!" << endl;
    }

private:
    int m_Id;

};

// 故而推荐的写法就是：不推荐使用引用，并且绝对不能使用指针
// 那么如何传递变量和字符串呢？必须添加const
void myPrint(const int i, const Student& name){ 

    cout << "id is: " << i << endl;

}

int main(int argc, char* argv[]){

    int id = 1006;

    thread myThreaad(myPrint, 1006, id); // 这里把id隐式地转换成Student类

    myThreaad.join();

    // myThreaad.detach();

    cout << "I love China!" << endl;

    return 0;
}

使用join()先看看正常地隐式转换：
在这里插入图片描述
那么，在使用detach()函数看看隐式没有转换成功地情况：
这里不打印主程序地 “I love China!”，使得主程序结束地更快。
在这里插入图片描述
可以看到，执行了两次都没有来的及执行隐式转换类对象。
那么使用临时对象呢？

thread myThreaad(myPrint, 1006, id);

在这里插入图片描述
那么可以清晰地看到，构造函数被执行了，拷贝构造也正常执行。当然，一般我们传递类对象的时候，都是先进行初始化的，所以临时对象也不太常用，这里主要是注意char类型的转string的情况。

这里使用vscode调试的时候，出现了两次拷贝构造(按理来讲应该只会执行一次拷贝构造)，vs2019出现一次拷贝构造，暂时还理不清楚。标记为一个bug。

总结：
（a）若传递int这种简单类型的参数，建议都是值传递，不要用引用，防止节外生枝
（b）如果传递类对象，避免隐式类型转换。全部都在创建线程这一行就构建出临时对象来，然后在函数参数里用引用来接；否则系统还会多构造一次对象，浪费。
（c）建议不使用detach()，只使用join()；这样就不存在局部变量失效导致线程对内存的非法引用的问题；

2、临时对象作线程参数再分析

2.1、线程id概念

id是个数字，每个线程（不管是主线程还是子线程）实际上都对应一个数字，而且每个线程对应的这个线程id可以用C++标准库里的函数来获取。

2.2、使用线程id进行分析

针对上述的bug，利用线程的id来查看是哪些线程调用了类的构造函数以及拷贝构造，这里为了显示代码的思绪清晰使用了join()函数进行分析。

 std::this_thread::get_id() // 获取线程的id

#include <iostream>
#include <thread>
#include <string>

using namespace std;

class Student{

public:
    Student(int id):m_Id(id){
        cout << "Constructor is running!" << "this thread id is: " << std::this_thread::get_id() << endl;
    }
    Student(const Student& stu):m_Id(stu.m_Id){
        cout << "Copy-constructor is running!" << "this thread id is: " << std::this_thread::get_id() << endl;
    }
    ~Student(){
        cout << "Destructor is running!" << "this thread id is: " << std::this_thread::get_id() << endl;
    }

private:
    int m_Id;

};

void myPrint(const Student& name){ 

    cout << "child thread id is: " << std::this_thread::get_id() << endl;

}

int main(int argc, char* argv[]){

    cout << "main thread id is: " << std::this_thread::get_id() << endl;

    int id = 1006;
    //Student stu(id);
    thread myThreaad(myPrint, id); // 这里把id隐式地转换成Student类

    myThreaad.join();

    //myThreaad.detach();

    //cout << "I love China!" << endl;

    return 0;
}

不使用临时对象的情况：
在这里插入图片描述
使用临时对象(VS2019)：
在这里插入图片描述
总结：在向子线程的入口函数传递参数时，使用直接传递或者引用(不能使用指针)，无论传递的是简单的数据类型还是类的临时对象，那么都属于 值传递，也就是说，属于深拷贝(类对象的深拷贝就是执行拷贝构造)。深拷贝都发生在当前线程内，而非当前线程的子线程。

那么这就引出一个问题，也就是无论是直接传递参数还是引用，thread内部都处理成值传递，那么在子线程内对参数进行修改，就不会影响当前线程内的数据的值。

注意：在子线程入口函数的传递使用引用方式，必须加上const修饰，保证线程安全，否者编译器报错。如：

void myPrint(const int& id, const Student& name) {

    cout << "child thread id is: " <<  std::this_thread::get_id() << endl;

}

3、传递类对象、智能指针为线程参数

3.1、地址传递类对象

上述文章中已经说明，为了保证线程运行安全，使用的引用方式被thread修改为了值传递，那么在子线程中进行对数据的修改不会影响主线程的数据，但是如果需要进行这种操作呢？

这时候就是用到了std::ref()函数了，这会告诉编译器，现在现在不再使用值传递而是地址传递了。
使用语法：

 thread myThreaad(myPrint, std::ref(stu)); // std::ref(stu)为子线程入口函数的参数

例如：

#include <iostream>
#include <thread>
#include <string>

using namespace std;

class Student {

public:
    Student(int id) :m_Id(id) {
        cout << "Constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    Student(const Student& stu) :m_Id(stu.m_Id) {
        cout << "Copy-constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    ~Student() {
        cout << "Destructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }

    void setId(const int id) {
        this->m_Id = id;
    }

    int getId() {
        return this->m_Id;
    }

private:
    int m_Id;

};

void myPrint(Student& stu) { // const不再添加

    cout << "child thread id is: " <<  std::this_thread::get_id() << endl;

    stu.setId(10);

}

int main(int argc, char* argv[]) {

    cout << "main thread id is: " << std::this_thread::get_id() << endl;

    Student stu(1006);
    cout << "Original data is； " << stu.getId() << endl;

    thread myThreaad(myPrint, std::ref(stu)); // 这里把id隐式地转换成Student类

    myThreaad.join();

    cout << "Modified data: " << stu.getId() << endl;

    cout << "I love China!" << endl;

    return 0;
}

在这里插入图片描述
注意：在使用std::ref()时，是地址传递，那么类对象就不会再执行拷贝构造了；而且入口函数的参数列表也不再使用const修饰

不能使用detach()

3.2、传递指针指针

使用std::move()

#include <iostream>
#include <thread>
#include <string>

using namespace std;

class Student {

public:
    Student(int id) :m_Id(id) {
        cout << "Constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    Student(const Student& stu) :m_Id(stu.m_Id) {
        cout << "Copy-constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    ~Student() {
        cout << "Destructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }

    void setId(const int id) {
        this->m_Id = id;
    }

    int getId() {
        return this->m_Id;
    }

private:
    int m_Id;

};

void myPrint(unique_ptr<Student> stu) {

    cout << "child thread id is: " <<  std::this_thread::get_id() << endl;

    stu->setId(10);
}

int main(int argc, char* argv[]) {

    cout << "main thread id is: " << std::this_thread::get_id() << endl;

    unique_ptr<Student> pStu(new Student(1006)); //创建一个智能指针
    cout << "Original data is； " << pStu->getId() << endl;

    //独占式指针只能通过std::move()才可以传递给另一个指针
    //传递后pStu就指向空，新的stu指向原来的内存
    //所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了
    thread myThreaad(myPrint, std::move(pStu)); // 这里把id隐式地转换成Student类

    myThreaad.join();

    // 同样的，也不能再使用pStu了
    // cout << "Modified data: " << pStu->getId() << endl;

    cout << "I love China!" << endl;

    return 0;
}

在这里插入图片描述

总结：智能指针传递同样没有拷贝构造，独占式指针只能通过std::move()才可以传递给另一个指针，传递后pStu就指向空，新的stu指向原来的内存，原始指针不能再使用。

这里不能使用detach()

4、成员函数指针作线程函数

#include <iostream>
#include <thread>
#include <string>

using namespace std;

class Student {

public:
    Student(int id) :m_Id(id) {
        cout << "Constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    Student(const Student& stu) :m_Id(stu.m_Id) {
        cout << "Copy-constructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }
    ~Student() {
        cout << "Destructor is running!" << " this thread id is: " << std::this_thread::get_id() << endl;
    }

    void setId(const int id) {
        this->m_Id = id;
    }

    int getId() {
        return this->m_Id;
    }

    void thread_work(int num) {
        cout << "child thread is running!" << " num = " << num <<  " this thread id is: " << std::this_thread::get_id() << endl;
    }

private:
    int m_Id;
};

int main(int argc, char* argv[]) {

    cout << "main thread id is: " << std::this_thread::get_id() << endl;

    Student stu(1006);

    thread myThread(&Student::thread_work, stu, 100); // 

    // myThread.join();
    myThread.detach();
    
    cout << "I love China!" << endl;

    return 0;
}

注意：上述程序中，入口函数时值传递，可以使用detach()

5、总结

入口函数无论是普通函数、仿函数、成员函数中的参数列表中包含真正的引用或指针时，也就是std::ref()或std::move()子线程不使用detach()。否者参数列表中均为值传递(普通传递或者即使写成引用都会在thread类内部处理成值传递)，可以使用detach()，以保证线程安全。

6、参考教程

https://blog.csdn.net/qq_33435360/article/details/106310510

__铭天
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11并发编程:多线程std::thread
08-26
C++11并发编程：多线程std::thread C++11引入了thread类，大大降低了多线程使用的复杂度。原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需...
操作系统基础---多线程
weixin_45863060的博客
02-09 1245
内核支持线程KST是在内核的支持下运行的，它们的创建，阻塞，撤销和切换等，都是在内核空间实现的。为了对内核线程进行控制和管理，在内核空间为每一个内核线程设置了一个线程控制块，内核根据该控制块而感知某线程的存在，并对其加以控制。当前大多数OS都支持内核支持线程。
操作系统--多线程基础(上)
weixin_53860901的博客
04-01 1079
目录前言一丶什么是线程<1>关于进程状态<2>创建线程的方式1>继承Thread类2>实现Runnable接口3>其他方式匿名内部类−−继承Thread类\color{red}{匿名内部类--继承Thread类}匿名内部类−−继承Thread类匿名内部类−−继承Runnable接口\color{red}{匿名内部类--继承Runnable接口}匿名内部类−−继承Runnable接口lambda表达式创建Runnable子类对象\color{red}{lambda表达
操作系统 --- 多线程 Multithreading
HelloWorld
03-25 1397
操作系统 -- 多线程 Multi-Threading什么是线程和多线程线程和进程的区别多线程的状态用户级线程 -- User Level Threads如何切换用户级线程 -- Yield函数如何创建用户级线程 -- Create函数内核级线程 -- Kernel Level Threads为什么需要内核级线用户级线程和核心级线程的区别用户栈和内核栈如何切换内核级线程如何创建内核级线程用户级线程和内核级线程的对比 什么是线程和多线程 线程是进程的最小组成单位, 任何一个进程都至少有一个线程 多线程
操作系统进程线程（一）—进程线程协程区别、多进程多线程、进程调度算法、进程线程通信
最新发布
qaaaaaaz的博客
04-27 597
有一些敏感的地址：对于32位进程来说，代码段从0X08048000开始，从0XC0000000开始到0XFFFFFFFF是内核地址空间，通常情况下代码运行在用户态（0X00000000~0XC0000000的用户地址空间），当发生系统调用、进程切换等操作时CPU控制寄存器设置模式位，进入内核模式，这个状态下进程可以访问全部存储器位置和执行全部指令。进程是一个独立的资源分配单元。不同进程（这里通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。
pyqt5使用thread 实现多个线程的启动与停止
scottar的博客
07-13 4348
文章目录说明的问题线程停止函数线程的建立与重新的启动结果验证 说明的问题 经常的时候，我们需要实现对额外的线程的启动与停止，例如，我们需要有的时候进行建立tcp的连接接收数据，有的时候需要保证系统资源，我们需要暂时停止当前的线程，因此需要实现对线程的启停。 线程停止函数 同时可以参考，之前我的一篇blog： https://blog.csdn.net/weixin_42066185/article/details/106670921 import inspect import ctypes def _as
c++11多线程编程
04-09
c++11多线程库的使用，主要介绍了thread类中的构造函数 join函数和detach函数的使用方式
C_C++ 多线程编程精髓_专栏.pdf.zip
07-06
《C/C++ 多线程编程精髓》是深入探讨操作系统层面多线程技术的重要资源，主要涵盖以下几个核心知识点： 1. **线程基础**：线程是操作系统分配CPU执行时间的基本单位，它允许一个进程中同时执行多个独立的代码段。在...
C++多线程编程实战-pdf
09-12
《C++多线程编程实战》是一本深入探讨C++多线程技术的书籍，它主要针对想要在C++环境中实现高效并发程序的开发者。在现代计算机系统中，多线程已经成为不可或缺的一部分，特别是在高性能计算、实时系统以及大规模...
6.C++中多线程.docx
11-23
本篇文章将详细介绍C++中多线程编程的基础知识，涵盖多线程的创建、线程之间的通信、线程加锁和线程解锁等方面的知识点。 一、多线程的创建 在C++中，使用std::thread类来创建线程。线程的创建可以通过构造函数的...
pyqt5线程的启动，暂停，恢复与停止
weixin_43054437的博客
04-07 1万+
简单介绍 在pyqt5中，如果不是特别复杂的程序，不建议手动操作线程，因为有时候不知道会发生什么致命的bug，在qt中操作线程的简单说明： QWaitCondition()用于多线程同步，一个线程调用QWaitCondition.wait()阻塞等待， 直到另外一个线程调用QWaitCondition.wake()唤醒才继续往下执行 QMutex()：是锁对象 线程执行的时候需要先上锁，并在运行的时候，定义一个判断标志，如果该标志触发就执行线程的挂起，直到再次唤醒。 案例一 主程序启动一个.
pyqt5——简单的多线程开始、暂停
DL_GIS
04-20 4239
pyqt5实现桌面便签及提醒
PyQt5多线程的执行和停止
菜鸟变大鸟的博客
03-18 4520
参考资料：哔哩哔哩 pyqt5 thread多线程示例 以下代码来自该视频，我自己手动实现了一下，当作一个模板来学习，欢迎大家一起学习。 运行示例
python多线程编程：如何优雅地关闭线程
热门推荐
Python技术探索
12-18 4万+
Python 多线程编程中， Threading中的Thread类并没有提供关闭线程的方法、经常会遇到中止主线程时，子线程仍然在运行。那么应该如何正确关闭线程、停止线程呢？提供了两种方式：1种用 线程通信 Event 类方式中止线程，另1种是利用全局状态变量来中止线程，都可以优雅地关闭线程，自动关闭线程，避免丢失数据，文件未关闭等异常，
【面试】如果把线程当作一个人来对待，所有问题都瞬间明白了
十指波课堂的博客
07-02 108
多线程的问题都曾经困扰过每个开发人员，今天将从全新视角来解说，希望读者都能明白。强烈建议去运行下文章中的示例代码，自己体会下。问题究竟出在哪里？一个线程执行，固然是安全的，但是有时太慢了，怎么办？老祖宗告诉我们，“一方有难，八方支援”，那不就是多叫几个线程来帮忙嘛，好办呀，多new几个不就行了，又不要钱。这样能管用吗？继续往下看。俗话说，“在家靠父母，出门靠朋友”。有了朋友的帮助，就会事半功倍。是...
Python多线程-如何停止循环线程？
Best_307的博客
03-10 4468
三个解决方案 1.螺纹可停止功能 可以将函数修改为允许以下操作，而不是将threading.Thread分为子类：停下一个标志。 我们需要一个运行函数可访问的对象，将标志设置为停止运行。 我们可以使用doit对象。 import threading import time def doit(arg): t = threading.currentThread() while getattr(t, "do_run", True): print ("working on %s"
『pyqt5 从0基础开始项目实战』12. 实现多线程循环检测数据的开始和停止（保姆级图文）
MZH
04-18 631
『pyqt5 从0基础开始项目实战』12. 实现多线程循环检测数据的开始和停止（保姆级图文）
Qt多线程的两种创建方法以及快速停止线程方法
m0_59119702的博客
04-14 7770
Qt多线程的两种创建方法（继承QThread，moveToThread方法）以及快速停止线程方法。
python中强制关闭线程、协程、进程方法
良知犹存的博客
11-27 1万+
python使用中多线程、多进程、多协程使用是比较常见的。那么如果在多线程等的使用，我们这个时候我们想从外部强制杀掉该线程请问如何操作？下面我就分享一下我的执行看法：
c++ concurrency in action笔记
03-25
C++ Concurrency in Action笔记详细介绍了C++11版本引入的多线程支持，以及如何在C++编程中有效地管理和利用并发。首先，C++11提供了对多线程的内置支持，使得并发编程成为可能，通过并发可以实现关注点分离和提高...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值