并发与多线程（2）join 、detach、临时对象作为子线程函数的参数

Σίσυφος1900

已于 2022-10-29 08:45:26 修改

阅读量430

点赞数

分类专栏： C++ 文章标签： c++

于 2022-10-28 16:53:02 首次发布

本文链接：https://blog.csdn.net/weixin_39354845/article/details/127568754

版权

C++ 专栏收录该内容

47 篇文章 5 订阅

订阅专栏

一、Join

join的功能：主线程需要等待子线程运行结束了才可以结束

join 让主线程阻塞，然后执行子线程。传统的线程是先执行完成子线程然后在完成后再将主线程退出，没有join，则会报错，而且输出的顺序也是错误的。

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

void  myprint()
{
    std::cout << " myprint ,Hello World!\n";
    std::cout << " 1myprint ,Hello World!\n";
    std::cout << " 2myprint ,Hello World!\n";
    std::cout << " 3myprint ,Hello World!\n";
    std::cout << " 4myprint ,Hello World!\n";
    std::cout << " 6myprint ,Hello World!\n";
    std::cout << " 7myprint ,Hello World!\n";
    std::cout << " 8myprint ,Hello World!\n";
    std::cout << " 9myprint ,Hello World!\n";
}

int main()
{
    std::cout << "Hello !\n";
    // 创建一个线程， 线程的入口是myprint这个函数  然后mythread线程开始执行
    thread mythread(myprint);
     //mythread.join();  // 主线程开始阻塞，开始执行mythread线程执行完成之后在执行主线程
    // mythread.join() 如果不加join 会有问题，也就是说 可能发生主线程已经执行完成，但是子线程换没有执行完成，这样就
    // 会导致程序报错，只有当子线程都完成之后，最后主线程才退出。
    std::cout << "Hello World!\n";
}

二、detach

detach 的功能：分离线程函数，使用detach()函数会让线程在后台运行，即说明主线程不会等待子线程运行结束才结束，是对上面一的一个补充。主线程和子线程各自执行，各扫门前雪，扫完后各自回家睡觉。

对上述情况我们主线程中添加代码，让其执行时间变长：

void  myprint()
{
    std::cout << " myprint ,Hello World!\n";
    std::cout << " 1myprint ,Hello World!\n";
    std::cout << " 2myprint ,Hello World!\n";
    std::cout << " 3myprint ,Hello World!\n";
    std::cout << " 4myprint ,Hello World!\n";
    std::cout << " 6myprint ,Hello World!\n";
    std::cout << " 7myprint ,Hello World!\n";
    std::cout << " 8myprint ,Hello World!\n";
    std::cout << " 9myprint ,Hello World!\n";
}

int main()
{
    std::cout << "Hello !\n";
    // 创建一个线程， 线程的入口是myprint这个函数  然后mythread线程开始执行
    thread mythread(myprint);
    // mythread.join();  // 主线程开始阻塞，开始执行mythread线程执行完成之后在执行主线程
    // mythread.join() 如果不加join 会有问题，也就是说 可能发生主线程已经执行完成，但是子线程换没有执行完成，这样就
    // 会导致程序报错，只有当子线程都完成之后，最后主线程才退出。
    mythread.detach();

        Sleep(1000);
        std::cout << "Hello World!\n";
        std::cout << " main  Hello World!\n";

  
}

注意：一旦使用了detach 就不能使用join 细品一下，同一个线程 join和detach 是相反的两个方法，不能共存。

那么什么时候能join呢？我们可以使用 joinable 这个函数来判断

joinable功能：可以判断是否能成功的调用join（）和 detach()函数

// CPPThreadStudy.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include<thread>
#include<vector>
#include<string>
#include <windows.h>
using namespace std;

void  myprint()
{
    std::cout << " myprint ,Hello World!\n";
    std::cout << " 1myprint ,Hello World!\n";
    std::cout << " 2myprint ,Hello World!\n";
    std::cout << " 3myprint ,Hello World!\n";
    std::cout << " 4myprint ,Hello World!\n";
    std::cout << " 6myprint ,Hello World!\n";
    std::cout << " 7myprint ,Hello World!\n";
    std::cout << " 8myprint ,Hello World!\n";
    std::cout << " 9myprint ,Hello World!\n";
}

int main()
{
    std::cout << "Hello !\n";
    // 创建一个线程， 线程的入口是myprint这个函数  然后mythread线程开始执行
     thread mythread(myprint);
    // mythread.join();  // 主线程开始阻塞，开始执行mythread线程执行完成之后在执行主线程
    // mythread.join() 如果不加join 会有问题，也就是说 可能发生主线程已经执行完成，但是子线程换没有执行完成，这样就
    // 会导致程序报错，只有当子线程都完成之后，最后主线程才退出。
   mythread.detach();
 
   
    if (mythread.joinable() == true)
    {
        //如果返回true，证明可以调用join()或者detach()
        cout << "可以调用可以调用join()或者detach()" << endl;
    }
    else
    {
        //如果返回false，证明调用过join()或者detach()，join()和detach()都不能再调用了
        cout << "不能调用可以调用join()或者detach()" << endl;
    }

        Sleep(1000);
        std::cout << "Hello World!\n";
        std::cout << " main  Hello World!\n";

  
}

我们用类来做一个测试

class  A
{
public:
    void  operator()() // 重载（） 方法，并且不带参数
    {
        std::cout << " A ,operator  start!\n";
        std::cout << " A ,operator over!\n";
    }
};

main函数：

    A a();  // 主线程中定义的A ，如果我们呢使用detach ,分类的话一旦主线程结束，这个A也就没有了，但是还有子线程在执行
    // A 中的任务，这里说就是有问题的。
    thread mythread(a);
    mythread.join();
    std::cout << "Hello World!\n";

Question：A这个对象是我们在主线程中调用了，我们用detach 的时候假如说主线程中的代码逻辑很简单但是A中执行的代码逻辑很复杂，要用很长的时间来完成，那我们detach 的时候，主线程已经结束，我们调用的那个A类的对象a,已经被析构了，这个是什么问题了？？

回答： 实际上这个对象是被复制到这个线程中去了，也就是说当我们用“引用 &” 、“指针” 的时候我们是在这个对象里面做了一个对象拷贝，当主线程中的A 对象a 结束被析构的时候，负责的那个a对象还是存在，继续执行任务的。我们可以做个实验：

 class  A
{
public :
    int m_1;
   A(int &m) : m_1(m)
    {
        std::cout << "A 的构造函数被执行!\n";
    }
    A(const  A&a):m_1(a.m_1)
    {
        std::cout << "A 的拷贝构造函数被执行!\n";
    }
    ~A()
    {
        std::cout << "~A 的析构构函数被执行!\n";
    }
public:
    void  operator()() // 重载（） 方法，并且不带参数
    {
        std::cout << " A ,operator  start!\n";
        std::cout << " A ,operator over!\n";
    }
};

main 函数：


int main()
{

    int m = 20;
    A a(m);  // 主线程中定义的A ，如果我们呢使用detach ,分类的话一旦主线程结束，这个A也就没有了，但是还有子线程在执行
    // A 中的任务，这里说就是有问题的。
    thread mythread(a);
    mythread.detach();
    Sleep(2000);

    std::cout << "Hello World!\n";
}

lambda 表达式：


int main()
{
    auto mylabbdaThread = []
    {
        std::cout << "mylabbdaThread,Hello World start!\n";
        std::cout << "mylabbdaThread,Hello World over !\n";
    };
    thread mylav(mylabbdaThread);
    mylav.join();
    std::cout << "Hello World!\n";
    return 0;
}

三、detach 细节

上面的都是没有参数的线程调用，现在我们来添加一些参数。

1、detach使用& 和指针的安全性

void myprint2(const int &i,char * cb)
{
    cout << i << endl;
    cout << cb << endl;
}
#if 1

//  传递临时对象作为线程的参数

int main()
{
    int i = 11;
    int& is = i;
    char  mybuf[] = "ccccccccccccccc";
    thread myjob3  (myprint2, is,mybuf); // 第一个参数是函数名，第二个参数及以后就是这个函数的参数
    myjob3.join();
  
    std::cout << "Hello World!\n";
    return 0;
}
#endif // 0

我们可以看出用join 的时候是没有问题的，那假如我们用detach 呢？？

结果没有问题，那我们断点看细节：

从上面两幅图片可以看出，我们能在用 & 的时候其实是值传递，地址是不同的，也就是使用引用是线程安全的

同样的我们来看一下指针 *

main 中定义一个char ,用指针传给子线程中并调用detach的时候线程是不安全的。

接着我们继续修改代码，同样的执行上面的步骤：

void myprint3(const int  i, const  string & abc)
{
    cout << i << endl;
    cout << abc << endl;
}

& 任然是值传递：

& 对象类型的可以看出结果是对的，涉及到了隐式转换，是什么时候呢，由于主线程中的mybuf 在线程结束之后才转换成string类型的：

接着改，使用临时对象，在主线程中将其使用临时对象转换成合适的对象：

    thread myjob3(myprint3, is, string(mybuf));  // 我们在主线程中将mybuf 转换成string (同一线程)，然后在让子线程来做  应用 & 
    myjob3.detach();

总结：

在使用detach的时候：

1、如果要传递int等类型的时候都是值传递，一般在在（子线程）函数中不用&

2、如果是类对象的传递，要避免隐式转换，要在创建这个线程的这一行临时构造出一个对象来，然后在函数的参数中做 & 。

3、最后建议能不用detach 就不用这个。

四、临时对象作为子线程函数的参数：

线程ID：

获取线程ID：

1、mutable 的功能：

注意点：如果作为参数使用& 的时候前面的修饰关键字一定是const ，如果不加const 15版本之前的不会报错，但是新的vs 肯定会报错

void myprint4(const B& abc)
{
abc.m_1 = 1999; // 我们这里修改不会影响到main 函数中的变量
cout << abc.m_1 << std::this_thread::get_id() << endl;

对比： const :

}

没有const

我们做一个测试：

#if 1

class  B
{
public:
      mutable  int m_1;
    B(int m) : m_1(m)
    {
        std::cout << "B 的构造函数被执行!     "<<this <<std::this_thread::get_id() << endl;
    }
    B(const  B& a) :m_1(a.m_1)
    {
        std::cout << "B 的拷贝构造函数被执行!      "<<this << std::this_thread::get_id() << endl;
    }
    ~B()
    {
        std::cout << "~B 的析构构函数被执行!       "<<this << std::this_thread::get_id() << endl;
    }
};



void myprint4(const  B& myb)
{
    myb.m_1 = 1999; // 我们这里修改不会影响到main 函数中的变量
    cout <<"子线程： " << myb.m_1 << std::this_thread::get_id() << endl;
}

int main()
{

    //std::cout << "main       " << std::this_thread::get_id() << endl;
    //int  main_i = 12;
    //thread myjob4(myprint4, B(main_i));  // 我们在主线程中将mybuf 转换成string (同一线程)，然后在让子线程来做  应用 & 

    B myobj5(20);
    thread myjob4(myprint4, myobj5);  //  类对象做为线程的参数
    myjob4.detach();
    Sleep(2000);
    std::cout << "Hello World!     "<< myobj5.m_1<<endl;

    return 0;
}
#endif // 0

从上面的测试可以得出，我们在子线程中是不能修改main中的值，那有什么办法来解决这个问题，让子线程中的值能修改main 中的值呢？？

2、std::ref

thread myjob4(myprint4, std::ref(myobj5));

输出结果：

#if 1

class  B
{
public:
    mutable  int m_1;
    B(int m) : m_1(m)
    {
        std::cout << "B 的构造函数被执行!     " << this << std::this_thread::get_id() << endl;
    }
    B(const  B& a) :m_1(a.m_1)
    {
        std::cout << "B 的拷贝构造函数被执行!      " << this << std::this_thread::get_id() << endl;
    }
    ~B()
    {
        std::cout << "~B 的析构构函数被执行!       " << this << std::this_thread::get_id() << endl;
    }
};



void myprint4(const  B& myb)
{
    myb.m_1 = 1999; // 我们这里修改不会影响到main 函数中的变量
    cout << "子线程： " << myb.m_1 <<"    ID ： "<< std::this_thread::get_id() << endl;
}

int main()
{

    //std::cout << "main       " << std::this_thread::get_id() << endl;
    //int  main_i = 12;
    //thread myjob4(myprint4, B(main_i));  // 我们在主线程中将mybuf 转换成string (同一线程)，然后在让子线程来做  应用 & 

    B myobj5(20);
    thread myjob4(myprint4, std::ref(myobj5));  //  类对象做为线程的参数
    myjob4.detach();
    Sleep(2000);
    std::cout << "Hello World!     " << myobj5.m_1 << endl;

    return 0;
}
#endif // 0

五、智能指针的传递：

智能指针用std::move 来向子线程传递参数，但是只能用于join 这中


#if 1  // 智能指针的传递

void myprint5(unique_ptr<int> myb)
{

    cout << "子线程：   ID ： " << std::this_thread::get_id() << endl;
}

int main()
{

    unique_ptr<int> myp(new int(100));
  
    thread myjob4(myprint5, std::move(myp));  //  类对象做为线程的参数
    myjob4.join();
    Sleep(2000);
    std::cout << "Hello World!     " << endl;

    return 0;
}
#endif // 0

join 已经验证了，那我们试一下detach

是什么愿意了，当主线程和子线程分离的时候，使用std::move 将主线程中的智能地址传到子线程的时候，主线程可能已经结束，内存已经释放，这个时候我们的子线程刚开始运行，要访问这块地址，但是在主线程中已经找不到了，这个时候就是出现了访问错误的问题

六、成员函数指针做线程的参数

用detach 也是OK的，测试：

同理我们：使用std::ref ,是不安全的

std::ref==&


#if 1  //成员函数指针做线程的参数

class  B
{
public:
    mutable  int m_1;
    B(int m) : m_1(m)
    {
        std::cout << "子线程：B 的构造函数被执行!     " << this << std::this_thread::get_id() << endl;
    }
    B(const  B& a) :m_1(a.m_1)
    {
        std::cout << "子线程：B 的拷贝构造函数被执行!      " << this << std::this_thread::get_id() << endl;
    }
    ~B()
    {
        std::cout << "子线程：~B 的析构构函数被执行!       " << this << std::this_thread::get_id() << endl;
    }
    void  dowork(int m)
    {
        cout << "  子线程： ~B  dowork： " << m  <<   "    ID ： " << std::this_thread::get_id() << endl;
     }
};
int main()
{

    B b(11);
    // 如果使用ref &  的话detach 是有问题的
    thread mythred(&B::dowork, std::ref(b), 14);  //吧B类的函数指针传进去 ，第二个参数是类对象，第三个参数才是值
    mythred.detach();
    std::cout << "Hello World!     "<<b.m_1<< endl;

    return 0;
}
#endif // 0