What is the issue with std::async?
c++, c++11, multithreading, stdasync
Solution
There are several issues:
`std::async` without a launch policy lets the runtime library choose whether to start a new thread or run the task in the thread that called `get()` or `wait()` on the future. As Herb says, this is the case you most likely want to use. The problem is that this leaves it open to the QoI of the runtime library to get the number of threads right, and you don't know whether the task will have a thread to itself, so using thread-local variables can be problematic. This is what Scott is concerned about, as I understand it.
Using a policy of `std::launch::deferred` doesn't actually run the task until you explicitly call `get()` or `wait()`. This is almost never what you want, so don't do that.
Using a policy of `std::launch::async` starts a new thread. If you don't keep track of how many threads you've got, this can lead to too many threads running.
Herb is concerned about the behaviour of the `std::future` destructor, which is supposed to wait for the task to complete, though MSVC2012 has a bug in that it doesn't wait.
For a junior developer, I would suggest:
- Use `std::async` with the default launch policy.
- Make sure you explicitly wait for all your futures.
- Don't use thread-local storage in the async tasks.
Problem
Near the beginning of this clip from C++ And Beyond, I heard something about problems with `std::async`. I have two questions: For a junior developer, is there a set of rules for what to do and what to avoid when using `std::async`? What are the problems presented in this video? Are they related to this article?