并发多线程3线程传参详解

第三节 线程传参详解

一、传递临时对象作为线程参数
要避免的陷阱1：

#include <iostream>
#include <thread>

using namespace std;

//void myprint(const int& i, char* pmbuf)
void myprint(const int i, const string &pmbuf)
{
    //如果线程从主线程detach了
    //i不是mvar真正的引用,是复制，实际上值传递，即使主线程运行完毕了，子线程用i仍然是安全的，但仍不推荐传递引用
    //推荐改为const int i
    cout << i << endl;
    //pmybuf还是指向原来的字符串，所以这么写是不安全的
    cout << pmbuf << endl;
    return;
}

int main()
{
    //传递临时对象作为线程参数
    int mvat = 1;
    int& mvary = mvat;
    char mybuf[] = "this is a test.";
    thread myobj(myprint, mvary, mybuf);
    myobj.join();
    std::cout << "Hello World!\n";
}

• 如果传递int这种简单类型，推荐使用值传递，不要用引用。

不建议用detach。

 

如果你传递了一个临时变量，而不是一个命名的变量；C++编译器会将其解析为函数声明，而不是类型对象的定义。

例如：

std::thread my_thread(background_task());

这里相当与声明了一个名为my_thread的函数，这个函数带有一个参数(函数指针指向没有参数并返回background_task对象的函数)，返回一个std::thread对象的函数，而非启动了一个线程。

解决：lambda表达式

std::thread my_thread([]{
  do_something();
  do_something_else();
});

二、临时对象作为线程参数继续讲

2.1线程id概念

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

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

std::ref(myObj)传递引用，不在传递拷贝对象

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

class A {
public:
    mutable int m_i; //m_i即使实在const中也可以被修改
    A(int i) :m_i(i) {}
};

void myPrint(const A& pmybuf)
{//pmybuf是拷贝过来的
    pmybuf.m_i = 199;//这里并不会改变myObj的数据
    cout << "子线程myPrint的参数地址是" << &pmybuf << "thread = " << std::this_thread::get_id() << endl;
}

int main()
{
    A myObj(10);
    //myPrint(const A& pmybuf)中引用不能去掉，如果去掉会多创建一个对象
    //const也不能去掉，去掉会出错
    //即使是传递的const引用，但在子线程中还是会调用拷贝构造函数构造一个新的对象，
    //所以在子线程中修改m_i的值不会影响到主线程
    //如果希望子线程中修改m_i的值影响到主线程，可以用thread myThread(myPrint, std::ref(myObj));
    //这样const就是真的引用了，myPrint定义中的const就可以去掉了，类A定义中的mutable也可以去掉了
    thread myThread(myPrint, myObj);
    myThread.join();
    //myThread.detach();

    cout << "Hello World!" << endl;
}

智能指针

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

void myPrint(unique_ptr<int> ptn)
{
    cout << "thread = " << std::this_thread::get_id() << endl;
}

int main()
{
    unique_ptr<int> up(new int(10));
    //独占式指针只能通过std::move()才可以传递给另一个指针
    //传递后up就指向空，新的ptn指向原来的内存
    //所以这时就不能用detach了，因为如果主线程先执行完，ptn指向的对象就被释放了
    thread myThread(myPrint, std::move(up));
    myThread.join();
    //myThread.detach();

    return 0;
}

 "移动(move)"是指:原始对象中的数据转移给另一对象，而转移的这些数据就不再在原始对象中保存了

当某个对象转移了线程的所有权后，它就不能对线程进行加入或分离。为了确保线程程序退出前完成，下面的代码里定义了scoped_thread类。

class scoped_thread
{
  std::thread t;
public:
  explicit scoped_thread(std::thread t_):                 // 1
    t(std::move(t_))
  {
    if(!t.joinable())                                     // 2
      throw std::logic_error(“No thread”);
  }
  ~scoped_thread()
  {
    t.join();                                            // 3
  }
  scoped_thread(scoped_thread const&)=delete;
  scoped_thread& operator=(scoped_thread const&)=delete;
};

struct func
{
  int& i;
  func(int& i_) : i(i_) {}
  void operator() ()
  {
    for (unsigned j=0 ; j<1000000 ; ++j)
    {
      do_something(i);          
    }
  }
};

void f()
{
  int some_local_state;
  scoped_thread t(std::thread(func(some_local_state)));    // 4
  do_something_in_current_thread();
}

不过这里新线程是直接传递到scoped_thread中④，而非创建一个独立的命名变量。当主线程到达f()函数的末尾时，scoped_thread对象将会销毁，然后加入③到的构造函数①创建的线程对象中去。这里把检查放在了构造函数中②，并且当线程不可加入时，抛出异常。

 

参考：C++并发编程实战