2009/9/25 Jason Cipriani
At the end of this message is a test program that uses boost::thread to create two threads. The first is one that takes a parameter by value, the second takes a parameter by reference. I have a couple of questions about some behavior here:
1) When passing by value, why are so many copies of the data made? The program output indicates that there are 9 (!) objects created (at most 5 exist simultaneously), when ideally there would be only 2 (the original and the copy passed to the thread).
That's common for generic boost libraries. If you care about the number of copies made, create your own function object that uses reference counting or something similar to hold an argument. struct runner { runner(const test& t) : arg_(new test(t)) {} void operator()() const { expected_nocopy(*arg_); } boost::shared_ptr<test> arg_; }; test t; runner r(t); boost::thread thr(r); By the way, there is no point in accepting argument by value, unless you want to modify it. Since your function expected_copy does not modify its argument, it's better to change pass-by-value to pass-by-const-ref.
2) When passing by reference, why is the data being copied? The copying behavior when passed by reference is identical to when the param is passed by value (9 objects created, 5 simultaneously). Also, and this isn't shown in the program below, but I would therefore expect the program to crash if the boost::thread outlived the referenced object (of course, it does not, since the object is copied).
Use boost::cref to pass by reference. boost::thread thr(expected_nocopy, boost::cref(t)); Roman Perepelitsa.