Threaded unique_ptr in a loop - c++

Question

A variant of
std::unique_ptr in a loop - memory leaks
In this modified question, RunSimulation() is a member method.
I would like one of the unique_ptr objects (sim) in main() to expire within main() and the other object (r) sent outside main() to free up in RunSimulation(). Would be great if you can provide a working code.
class Result { public: int n; };
class Simulation
{
public:
void RunSimulation(std::unique_ptr<Result> result) {result->n = 0;}
};
void main()
{
boost::thread_group threads;
std::unique_ptr<Result> r;
std::unique_ptr<Simulation> sim = std::make_unique<Simulation>();
for (int i = 0; i < 10; i++)
{
r = std::unique_ptr<Result>(new Result);
//Erroneous lines:
//threads.create_thread(boost::bind(&Simulation::RunSimulation, boost::ref(sim), std::move(r)));
//threads.create_thread([&] {sim->RunSimulation(std::move(r)); });
}
threads.join_all();
}

Answer 1

Your attempt to pass the functor created by boost::bind to create_thread fails because of the reason I explained in my answer to your previous question.
The attempt with the lambda should compile, but it has a subtle bug that will cause undefined behavior. I may have mislead you with my earlier answer, but this is the reason posting an MCVE is so important. The small snippet you posted in your previous question doesn't show how you intend to use the code.
The problem with the lambda is that it only stores a reference to the unique_ptr. You don't transfer ownership until the call to RunSimulation executes, in other words, transfer of ownership only happens after the thread execution has begun. But by that time the for loop within main may have moved on to the next iteration, causing the Result held by the unique_ptr in the previous iteration to be deleted. Dereferencing the unique_ptr within RunSimulation then causes undefined behavior.
The way around this is to transfer ownership of the unique_ptr immediately to the lambda, and then have the lambda again transfer ownership in the call to RunSimulation. This following lambda expression does what you want
[&sim, r=std::move(r)] () mutable {
sim->RunSimulation(std::move(r));
}
To explain what's going on, the lambda is capturing sim by reference (&sim) and it's using C++14's lambda init capture to transfer ownership of r within main to an r that is member of the lambda (r=std::move(r)) (you can call the lambda's member r something else if you want). The lambda itself needs to be mutable because you need to have non-const access to the r data member so you can move it when calling RunSimulation.
Unfortunately, this is not the end of your problems. Calling create_thread with the above lambda still doesn't compile because according to the documentation, it requires the callable object to be copyable. Your lambda isn't copyable because it has a unique_ptr data member.
A workaround is to create a boost::thread and then add_thread it to the thread_group.
auto t = new boost::thread([&sim, r=std::move(r)] () mutable {
sim->RunSimulation(std::move(r));
});
threads.add_thread(t);
Note that I can't find any documentation on exception safety guarantees that add_thread makes. So it's possible if an exception occurs while add_thread attempts to add the new thread to the thread_group, your thread object might leak.
Live demo
Finally, I think you need to rethink your design. Presumably, the Result object is supposed to hold the simulation result. What's the point of having RunSimulation store that in Result if you cannot access that Result within main after the simulation has ended?
As I suggested in the comments of my previous answer, you should probably create a container of Results in main and pass references to the elements of those containers to RunSimulation.