How to use packaged_task correctly? - c++

Question

I have a regular method that sometimes takes too long. There is a request to implement this method differently and to exit on timeout. Unfortunately the procedure cannot be interrupted, so it has to be finished, but I can return from the function leaving the procedure running in a separate thread. I've implemented it using a packaged_task pattern:
int mayTakeTooLong() {
auto asyncProcedure = []() -> int {
// Old code is here
};
std::packaged_task<int()> task(std::move(asyncProcedure));
auto future = task.get_future();
std::thread workerThread(task);
switch (future.wait_for(std::chrono::seconds(1))) {
case std::future_status::ready:
workerThread.join();
return future.get();
case std::future_status::timeout:
workerThread.detach();
return 0;
}
}
Disregard for now the fact that I'm detaching the thread in case of a timeout: in actual implementation trickier.
Now imagine that there is a parameter of the function that is passed by reference:
int mayTakeTooLong(const std::vector<SomeClass> &values);
Due to the fact the asyncProcedure may run longer than the lifetime of the vector, I need to copy it somewhere. My first implementation [I guess] was incorrect. I was passing the vector by value to the lambda itself:
int mayTakeTooLong() {
auto asyncProcedure = [](std::vector<SomeClass> values) -> int {
// Old code is here
};
std::packaged_task<int(std::vector<SomeClass>)> task(std::move(asyncProcedure));
auto future = task.get_future();
std::thread workerThread(task, values);
// ...
}
The problem with this code is that the values are copied asynchronously and not in the constructor of the thread, being synchronized with the beginning of the invocation of the lambda. So the first question is whether my understanding is correct.
A more safe idea is to capture the object into the lambda:
int mayTakeTooLong(const std::vector<SomeClass> &values) {
auto asyncProcedure = [values]() -> int {
// Old code is here
};
// ...
}
The values are being copied by value and become the part of the lambda. But in this case each time the lambda is being copied itself the vector would be copied as well. I'm trying to prevent the copying be moving the lambda:
int mayTakeTooLong(const std::vector<SomeClass> &values) {
auto asyncProcedure = [values]() -> int {
// Old code is here
};
std::packaged_task<int()> task(std::move(asyncProcedure));
// ...
}
As I can see, the lambda is never copied, but is that guaranteed by the standard? What could be a better option to implement this pattern?