C++多线程基础学习笔记（三）

一、detach（）大坑

上一篇随笔（二）中提到detach()是用来分离主线程和子线程的，那么需要考虑一个问题，就是如果主线程跑完了，主线程中定义的变量就会被销毁（释放内存），这时回收变量仍作为参数传入子线程，那么就会出现问题，下面用一个例子详细说明。

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

void MyThread(const int& a, char* str)
{
    cout << a << endl;
    cout << str << endl;
}
int main()
{
    
    int n = 20;
    char str_m[] = "hello wrold";
    thread MyThreadObj(MyThread, n, str_m);
    if (MyThreadObj.joinable())
    {
        MyThreadObj.detach();
    }
    cout << "main_thread" << endl;
    system("pause");
    return 0;
}

由监视图可知，实参n和形参a的地址并不同，所以实际是值传递，并因此最好不要用引用，直接用值传递就行了。

主线程的str_m和str的地址却相同，那么当子线程和主线程分离时，就会出现问题。这里讲一个改进的方法，把形参char* str改成const string& str,即把传进来的参数隐式地转换成一个（构造了）string对象，会发现主线程的str_m和子线程形参str的地址是不同的，但实际上问题还是存在，如果在在传递主线程的参数str_m前，str_m就被回收了，一个被回收的变量作为参数结果可想而知。所以还要再改多一步，就是在main()中实参str_m改成string(str_m)，先构造一个string对象，再将这个对象作为参数传入子线程，这时又会有疑问，难道不会出现在string(str_m)前str_m就被系统回收了吗？答案是不会的，测试方法这里不细说了。

下面是改进后的代码

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

void MyThread(int a, const string& str)
{
    cout << a << endl;
    cout << str << endl;
}
int main()
{
    
    int n = 20;
    char str_m[] = "hello wrold";
    thread MyThreadObj(MyThread, n, string(str_m));
    if (MyThreadObj.joinable())
    {
        MyThreadObj.detach();
    }
    cout << "main_thread" << endl;
    system("pause");
    return 0;
}

 二、std::this_thread::get_id()

线程id，每个线程都有自己的线程id，各个id都不同，获取线程id方法为std::this_thread::get_id()

#include <iostream>
#include <string>
#include <thread>
using namespace std;
class CA
{
public:
    int a;
    CA(int m) :a(m) 
    {
        cout << "构造函数执行 " << endl;
    }
    CA(const CA&m) :a(m.a) 
    {
        cout << "拷贝构造函数执行 " << endl;
    }
};
void MyThread(const CA&cc) 
{
    cout << "子线程id：" << this_thread::get_id() << endl;
    cout << cc.a << endl;
}
int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    CA ca(10);
    thread mythreadObj(MyThread,ca);
    mythreadObj.join();
    system("pause");
    return 0;
}

三、std::ref()

上述代码运行可知，如果向子线程传入一个对象，会调用拷贝构造函数，这时用detach()是安全的，但是如果想要通过子线程来修改主线程对象的数据是不允许的，可以把18行的const去掉试试，是会报错的，那么可以用std::ref()来使这个对象得以修改。（当然，18行处也可以改成void MyThread(CA cc），这样也是可以修改，但是修改的只是拷贝的对象，对主线程的对象没有影响，而且会调用两次拷贝构造函数，浪费内存）

#include <iostream>
#include <string>
#include <thread>
using namespace std;
class CA
{
public:
    int a;
    CA(int m) :a(m) 
    {
        cout << "构造函数执行 " << endl;
    }
    CA(const CA&m) :a(m.a) 
    {
        cout << "拷贝构造函数执行 " << endl;
    }
};
void MyThread(CA& cc) 
{
    cc.a++;
    cout << "子线程id：" << this_thread::get_id() << endl;
    cout << "my_thread " <<"ca.a:" << cc.a << endl;
}
int main()
{
    cout << "主线程id:" << this_thread::get_id() << endl;
    CA ca(10);
    thread mythreadObj(MyThread, ref(ca));
    cout << "main_thread " << "ca.a:" << ca.a << endl;
    mythreadObj.join();
    system("pause");
    return 0;
}

由结果可知，并不会调用拷贝构造函数，在子线程中操作的是主线程中的对象。这时需要注意了，如果用detach()，就不安全了。还是那个问题，对已经释放的变量进行非法操作必定带来隐患。