• 2.2 向线程函数传递参数

    2.2 向线程函数传递参数

    清单2.4中，向std::thread构造函数中的可调用对象，或函数传递一个参数很简单。需要注意的是，默认参数要拷贝到线程独立内存中，即使参数是引用的形式，也可以在新线程中进行访问。再来看一个例子：

    1. void f(int i, std::string const& s);
    2. std::thread t(f, 3, "hello");

    代码创建了一个调用f(3, “hello”)的线程。注意，函数f需要一个std::string对象作为第二个参数，但这里使用的是字符串的字面值，也就是char const *类型。之后，在线程的上下文中完成字面值向std::string对象的转化。需要特别要注意，当指向动态变量的指针作为参数传递给线程的情况，代码如下：

    1. void f(int i,std::string const& s);
    2. void oops(int some_param)
    3. {
    4.   char buffer[1024]; // 1
    5.   sprintf(buffer, "%i",some_param);
    6.   std::thread t(f,3,buffer); // 2
    7.   t.detach();
    8. }

    这种情况下，buffer①是一个指针变量，指向本地变量，然后本地变量通过buffer传递到新线程中②。并且，函数有很有可能会在字面值转化成std::string对象之前崩溃(oops)，从而导致一些未定义的行为。并且想要依赖隐式转换将字面值转换为函数期待的std::string对象，但因std::thread的构造函数会复制提供的变量，就只复制了没有转换成期望类型的字符串字面值。

    解决方案就是在传递到std::thread构造函数之前就将字面值转化为std::string对象：

    1. void f(int i,std::string const& s);
    2. void not_oops(int some_param)
    3. {
    4.   char buffer[1024];
    5.   sprintf(buffer,"%i",some_param);
    6.   std::thread t(f,3,std::string(buffer));  // 使用std::string，避免悬垂指针
    7.   t.detach();
    8. }

    还可能遇到相反的情况：期望传递一个非常量引用(但这不会被编译)，但整个对象被复制了。你可能会尝试使用线程更新一个引用传递的数据结构，比如：

    1. void update_data_for_widget(widget_id w,widget_data& data); // 1
    2. void oops_again(widget_id w)
    3. {
    4.   widget_data data;
    5.   std::thread t(update_data_for_widget,w,data); // 2
    6.   display_status();
    7.   t.join();
    8.   process_widget_data(data);
    9. }

    虽然update_data_for_widget①的第二个参数期待传入一个引用，但是std::thread的构造函数②并不知晓；构造函数无视函数期待的参数类型，并盲目的拷贝已提供的变量。不过，在代码会将参数以右值的方式进行拷贝传递，这是为了照顾到那些只能进行移动的类型，而后会以右值为参数调用update_data_for_widget。因为函数期望的是一个非常量引用作为参数，而非一个右值作为参数，所以会在编译时出错。对于熟悉std::bind的开发者来说，问题的解决办法是显而易见的：可以使用std::ref将参数转换成引用的形式，从而可将线程的调用改为以下形式：

    1. std::thread t(update_data_for_widget,w,std::ref(data));

    在这之后，update_data_for_widget就会接收到一个data变量的引用，而非一个data变量拷贝的引用，这样代码就能顺利的通过编译。

    如果你熟悉std::bind，就应该不会对以上述传参的形式感到奇怪，因为std::thread构造函数和std::bind的操作都在标准库中定义好了，可以传递一个成员函数指针作为线程函数，并提供一个合适的对象指针作为第一个参数：

    1. class X
    2. {
    3. public:
    4.   void do_lengthy_work();
    5. };
    6. X my_x;
    7. std::thread t(&X::do_lengthy_work,&my_x); // 1

    这段代码中，新线程将my_x.do_lengthy_work()作为线程函数；my_x的地址①作为指针对象提供给函数。也可以为成员函数提供参数：std::thread构造函数的第三个参数就是成员函数的第一个参数，以此类推(代码如下，译者自加)。

    1. class X
    2. {
    3. public:
    4.   void do_lengthy_work(int);
    5. };
    6. X my_x;
    7. int num(0);
    8. std::thread t(&X::do_lengthy_work, &my_x, num);

    有趣的是，提供的参数可以移动，但不能拷贝。”移动”是指:原始对象中的数据转移给另一对象，而转移的这些数据就不再在原始对象中保存了(译者：比较像在文本编辑的”剪切”操作)。std::unique_ptr就是这样一种类型(译者：C++11中的智能指针)，这种类型为动态分配的对象提供内存自动管理机制(译者：类似垃圾回收)。同一时间内，只允许一个std::unique_ptr实现指向一个给定对象，并且当这个实现销毁时，指向的对象也将被删除。移动构造函数(move constructor)和移动赋值操作符(move assignment operator)允许一个对象在多个std::unique_ptr实现中传递(有关”移动”的更多内容，请参考附录A的A.1.1节)。使用”移动”转移原对象后，就会留下一个空指针(NULL)。移动操作可以将对象转换成可接受的类型，例如:函数参数或函数返回的类型。当原对象是一个临时变量时，自动进行移动操作，但当原对象是一个命名变量，那么转移的时候就需要使用std::move()进行显示移动。下面的代码展示了std::move的用法，展示了std::move是如何转移一个动态对象到一个线程中去的：

    1. void process_big_object(std::unique_ptr<big_object>);
    3. std::unique_ptr<big_object> p(new big_object);
    4. p->prepare_data(42);
    5. std::thread t(process_big_object,std::move(p));

    std::thread的构造函数中指定std::move(p)，big_object对象的所有权就被首先转移到新创建线程的的内部存储中，之后传递给process_big_object函数。

    c++标准线程库中和std::unique_ptr在所属权上有相似语义类型的类有好几种，std::thread为其中之一。虽然，std::thread实例不像std::unique_ptr那样能占有一个动态对象的所有权，但是它能占有其他资源：每个实例都负责管理一个执行线程。执行线程的所有权可以在多个std::thread实例中互相转移，这是依赖于std::thread实例的可移动且不可复制性。不可复制保性证了在同一时间点，一个std::thread实例只能关联一个执行线程；可移动性使得开发者可以自己决定，哪个实例拥有实际执行线程的所有权。