传递给线程后保持引用有效

Question

I have a graph object that I am passing into a thread like this:

void MyClass::execute_subqueries(Graph& g, vector<query>&& queries) {
  for (size_t i = 0; i < queries.size(); i++) {
    threads.emplace_back(thread(my_thread, ref(g), queries[i]));
  }
}

I want to make a copy of the Graph object g because I will make changes to it as my thread is running. I only want to make one copy and pass a reference to all the threads I'm starting in the for loop. I don't want to make a copy for each thread because the Graph is large and it's expensive to clone it.

The problem is that I can't figure out how to keep my Graph object alive. I think after I pass in the reference, the Graph object gets deallocated and my threads do not produce the result I expect. What is a good way to do this?

Answer 1

Your flags tell me that you use c++11, so why don't you use a

std::vector< std::shared_ptr<Graph> > graphs;

and pass the shared pointers to the threads? They will keep your graphs alive as long as they are used and take care of the cleanup afterwards...

Answer 2

Since you want to make a copy of the graph, you might as well place it in an std::shared_ptr , and pass it to each of the threads (note that you'll be passing copies of the same pointer, so there won't be a copy per thread).

Consider something like this:

// A vector of pointers to Graph
vector<shared_ptr<Graph>> graphs;

...

// Make a shared allocated copy.
graphs.emplace_back(std::make_shared<Graph>(g));

(Note that this requires c++11 settings.)

Answer 3

It can be done using shared_ptr as suggested in the other answers but it really depends on what your program is doing. Before the for loop can try:

std::shared<Graph> gPtr(new Graph(g));
//std::shared<Graph> gPtr(g.clone()); // guess, you mentioned cloning

Then start the threads. Naming can be better. I presume my_thread is not really a thread instance but a function (else it won't compile). Make it take a shared_ptr instead of reference, etc.

You probably meant - if threads is std::vector (guess):

threads.push_back(std::thread(my_thread_fct, gPtr, queries[i]));

or

threads.emplace_back(my_thread_fct, gPtr, queries[i]);

@JoachimPileborg is right - need more context/code to understand what is going on. What is the output of all this? Would you extract something from that processed cloned Graph or else? Depending on those design decisions the code would look pretty different...