C++并发实战3：向thread传递参数

         在创建thread object时可以向线程传递参数，默认情况下，参数会被拷贝到线程空间以供线程执行时存取，即使参数是引用也是这样。

情形1：

void f(int i,std::string const& s);
        boost::thread t(f,3,”hello”);            //字符串常量“hello”会被转换为string，该string在线程中存在。

情形2：

void f(int i,std::string const& s);
void oops(int some_param)
{
 char buffer[1024]; 
 sprintf(buffer, "%i",some_param);
 boost::thread t(f,3,buffer); //换成boost::thread t(f,3,string(buffer))保证安全
 t.detach();
}

这里会存在一个潜在的风险：当oops退出时，buffer会被销毁，但是如果此时在子线程中buffer还没有被转化成string，将会出现dangle pointer。一个解决办法是：boost::thread t(f,3,string(buffer));此时thread在构造时就会将buffer转换为string，并将string拷贝至子线程地址空间。

情形3：thread构造会拷贝其参数

#include<iostream>
#include<string>
#include<boost/thread.hpp>
#include<unistd.h>
using namespace std;
class test{
    public:
        test(int i=0):data(i){}
        test(const test& one){
            data=one.data;
            cout<<"test::copy constructor"<<endl;
        }
        test& operator=(const test& one){
            data=one.data;
            cout<<"test::operator=()"<<endl;
            return *this;
        }
        ~test(){
            cout<<"test::destructor"<<endl;
        }
    public:
        int data;
};
void func(test& one){
    cout<<"func get the data "<<one.data<<endl;
}
void oops(){
    test one(10);
    boost::thread t(func,one);
    t.join();
}
int main(){
    oops();
    return 0;
}

程序输出：

test::copy constructor
test::copy constructor
test::copy constructor
test::copy constructor
test::copy constructor
test::destructor
test::copy constructor
test::destructor
test::destructor
test::copy constructor
test::copy constructor
test::destructor
test::destructor
test::destructor
test::destructor
func get the data 10                  //这里是线程函数的输出
test::destructor
test::destructor
   说明：即使线程函数func采用引用方式，thread并不知道这一情形，所以在thread object在构造时会盲目的拷贝test one，然后thread将这个对象拷贝到线程地址空间作为internal copy，此后线程函数引用的是线程地址空间的那个internal copy，线程执行完毕，thread会销毁internal copy。对于这一点和boost::bind也一样，boost::bind也会拷贝参数。至于上面程序出现的那么多拷贝和析构输出已经我已无力解释了sorry。

情形4： 有些时候需要向线程传递一个引用，由线程执行一些计算最后这个计算结果将在主线程中使用，可以用boost::ref传递一个引用到线程空间。

#include<iostream>
#include<string>
#include<boost/thread.hpp>
#include<boost/ref.hpp>
#include<unistd.h>
using namespace std;
class test{
    public:
        test(int i=0):data(i){}
        test(const test& one){
            data=one.data;
            cout<<"test::copy constructor"<<endl;
        }
        test& operator=(const test& one){
            data=one.data;
            cout<<"test::operator=()"<<endl;
            return *this;
        }
        ~test(){
            cout<<"test::destructor"<<endl;
        }
    public:
        int data;
};
void func(test& one){
    cout<<"func get the data "<<one.data++<<endl;
}
void oops(){
    test one(10);
    boost::thread t(func,boost::ref(one));
    t.join();
    cout<<"oops() get the data "<<one.data<<endl;
}
int main(){
    oops();
    return 0;
}

程序输出：

func get the data 10          //子线程修改数据
oops() get the data 11     //主线程将得到子线程修改后的结果，因为boost::ref是传递引用，没有拷贝构造之类的
test::destructor

情形5：thread传递函数对象

#include<iostream>
#include<boost/thread.hpp>
using namespace std;
class test{
    public:
        test(int i=0):data(i){}
        ~test(){
            cout<<"test::destructor"<<endl;
        }
        test(const test& one){
            data=one.data;
        }
        test& operator=(const test& one){
            data=one.data;
            return *this;
        }
        void operator()(){
            cout<<"test::operator() "<<data<<endl;
        }
        void show(){
            cout<<"test::show() "<<data<<endl;
        }
    public:
        int data;
};
void oops(){
    boost::thread t((test()));
    t.join();
}
int main(){
    oops();
    return 0;
}

程序输出：

test::destructor                 //函数对象没有产生copy constructor
test::destructor
test::destructor
test::operator() 0
test::destructor

情形6：仿照boost::bind将对象的成员函数作为线程函数

#include<iostream>
#include<boost/thread.hpp>
using namespace std;
class test{
    public:
        test(int i=0):data(i){}
        ~test(){
            cout<<"test::destructor"<<endl;
        }
        test(const test& one){
            data=one.data;
        }
        test& operator=(const test& one){
            data=one.data;
            return *this;
        }
        void operator()(){
            cout<<"test::operator() "<<data<<endl;
        }
        void show(){
            cout<<"test::show() "<<data<<endl;
        }
    public:
        int data;
};
void oops(){
    test one(10);
    boost::thread my_thread(&test::show,&one);
    my_thread.join();
}
int main(){
    oops();
    return 0;
}

程序输出：

test::show() 10             
test::destructor

     说明：此时thread的线程将调用one::show()，thread将&one当做对象地址传递到线程中。

情形7：向thread传递指针：普通指针和智能指针。

#include<iostream>
#include<boost/thread.hpp>
#include<boost/shared_ptr.hpp>
using namespace std;
class test{
    public:
        test(int i=0):data(i){}
        ~test(){
            cout<<"test::destructor"<<endl;
        }
        test(const test& one){
            data=one.data;
        }
        test& operator=(const test& one){
            data=one.data;
            return *this;
        }
    public:
        int data;
};
void fun(boost::shared_ptr<test> ptr){
    ptr->data++;
}
void fun_(test* ptr){
    ptr->data++;
}
void oops(){
    boost::shared_ptr<test> ptr(new test(10));
    boost::thread my_thread(fun,ptr);
    my_thread.join();
    cout<<"shared_ptr "<<ptr->data<<endl;
    test* one=new test(10);
    boost::thread t(fun_,one);
    t.join();
    cout<<"test* "<<one->data<<endl;
    delete one;
}
int main(){
    oops();
    return 0;
}

程序输出：

shared_ptr 11         //智能指针
test* 11                     //普通指针
test::destructor
test::destructor

            说明：传递指针给线程函数，thread拷贝的是指针对象，故线程对指针所指对象的修改将会影响到主线程中的对象。注意的是智能指针可能会引起对象生命周期的延长，若thread::detach那么智能指针肯定比普通裸指针安全，特别是detach后oops退出，智能指针管理的对象由于引用计数不会被析构，而普通裸指针由于oops退出析构了局部对象导致dangle pointer。

情形8：std::unique_ptr的movable语义传递参数

void process_big_object(std::unique_ptr<big_object>);
std::unique_ptr<big_object> p(new big_object);
p->prepare_data(42);
std::thread t(process_big_object,std::move(p));//为什么一定要用std::move?std::unique_ptr是个左值对象，std::move的功能是将左值转为右值使用

  说明：std::unique_ptr不能共享所有权，但是可以转移所有权，采用std::move()语义后原来的std::unique_ptr将为NULL。