Is it safe to pass arguments by reference into a std::thread function?

Question

#include <thread>
#include <string>
#include <vector>
#include <chrono>

using namespace std;

void f(const vector<string>& coll)
{
    this_thread::sleep_for(1h);

    //
    // Is coll guaranteed to be valid before exiting this function?
    //
}

int main()
{
    {
        vector<string> coll(1024 * 1024 * 100);
        thread(f, coll).detach();
    }

    //
    // I know std::thread will copy arguments into itself by default, 
    // but I don't know whether these copied objects are still valid
    // after the std::thread object has been destroyed.
    //

    while (true);
}

Is it safe to pass arguments by reference into a std::thread function?

Answer 1

As @T.C.'s comment, you're not passing reference to thread, you just make a copy of the vector in the thread:

thread(f, coll).detach(); // It's NOT pass by reference, but makes a copy.

If you really want to pass by reference, you should write this:

thread(f, std::ref(coll)).detach(); // Use std::ref to pass by reference

Then the code will get segment fault if the thread tries to access the vector, since when the thread runs, it's very likely the vector is already destructed (because it went out of it's scope in the main program).

So to your question:

Is it safe to pass arguments by reference into a std::thread function?

• It is safe if you're sure the object remains valid during the thread's running;
• It is NOT safe if the object is destructed, and you will get segment fault.

Answer 2

• Is coll guaranteed to be valid before exiting this function?

  • Updated: Yes. When you pass coll to the constructor of a std::thread in main function, because coll is an object, it is decay copied. This decay copy essentially moves the vector (so it becomes rvalue), which will bind to the coll parameter in f during the execution of the thread. (Thanks for the comment by @Praetorian)

• Is it safe to pass arguments by reference into a std::thread function?

  • Your arguments are decay copied, so you actually never pass anything by reference to std::thread.

• Reference for std::decay: http://www.cplusplus.com/reference/type_traits/decay/

• The accepted answer in this question std::thread with movable, non-copyable argument explained what happens to the arguments passed to std::thread