构造一个std :: thread via（Args && ...）

Question

I was wondering if there is much of a difference between various ways of constructing an std::thread in the following ways.

#include <iostream>
#include <thread>

void test ()
{
    int x = 5;

    auto example1 = std::thread([x] () {
        std::cout << x;
    });

    auto example2 = std::thread([] (int x) {
        std::cout << x;
    }, x);
}

According to http://en.cppreference.com/w/cpp/thread/thread/thread , with the example2 case, I get x copied/moved "to thread-accessible storage". I'm not sure what to make of this.

Does this storage help protect against false sharing or something like that?

Or is the main reason for passing in these arguments directly into the std::thread constructor there to make calling non-lambda functions a tad simpler? For example, to avoid the boilerplate given by example3 by using example4 :

#include <iostream>
#include <thread>

void foo (int x);

void test ()
{
    int x = 5;

    auto example3 = std::thread([x] () {
        foo(x);
    });

    auto example4 = std::thread(foo, x);
}

Answer 1

There's no real difference between example1 and example2 . The cppreference description of the thread( Function&& f, Args&&... args ); constructor is slightly off - DECAY_COPY , as the standard calls it, is performed for both the functor f and the arguments args... .

In other words, the created thread has its own copy of the functor (which includes anything captured by the lambda) and any arguments you passed; this makes it harder for you to write a data race or cause undefined behavior with dangling pointers and references. After all, the lambda expression creates a temporary functor that is destroyed at the next ; . If thread 's constructor didn't make a copy, you'd be in deep trouble.

Whether you choose to pass everything in a lambda, or use the bind -like way of passing the arguments separately, is mostly a matter of style. Sometimes it can be difficult to use the bind -like version, for instance if the function you want to call is overloaded or is a function template. Other times you may not be able to capture something in a lambda, especially pre-C++14.