Why would concurrency using std::async be faster than using std::thread?

23

I was reading Chapter 8 of the "Modern C++ Programming Cookbook, 2nd edition" on concurrency and stumbled upon something that puzzles me.

The author implements different versions of parallel map and reduce functions using std::thread and std::async. The implementations are really close; for example, the heart of the parallel_map functions are

// parallel_map using std::async
...
tasks.emplace_back(std::async(
  std::launch::async,
  [=, &f] {std::transform(begin, last, begin, std::forward<F>(f)); }));
...

// parallel_map using std::thread
...
threads.emplace_back([=, &f] {std::transform(begin, last, begin, std::forward<F>(f)); });
...

The complete code can be found here for std::thread and there for std::async.

What puzzles me is that the computation times reported in the book give a significant and consistent advantage to the std::async implementation. Moreover, the author acknowledge this fact as being obvious, without providing any hint of justification:

If we compare this [result with async] with the results from the parallel version using threads, we will find that these are faster execution times and that the speedup is significant, especially for the fold function.

I ran the code above on my computer, and even though the differences are not as compelling as in the book, I find that the std::async implementation is indeed faster than the std::thread one. (The author also later brings in standard implementations of these algorithms, which are even faster). On my computer, the code runs with four threads, which corresponds to the number of physical cores of my CPU.

Maybe I missed something, but why is it obvious that std::async should run faster than std::thread on this example? My intuition was that std::async being a higher-level implementation of threads, it should take at least the same amount of time, if not more, than threads -- obviously I was wrong. Are those findings consistent, as suggested by the book, and what is the explanation?

c++ multithreading

Share

Improve this question

edited Apr 10 at 13:33

Andreas Wenzel

4,66011 gold badge77 silver badges2424 bronze badges

asked Apr 10 at 13:26

user209974user209974

1,30711 gold badge77 silver badges1818 bronze badges

1

• 6
  Some implementations of std::async use a thread pool internally to avoid the overhead of spawning and destroying threads more than once, although I’m not sure if that would explain what you are seeing or not. – Jeremy Friesner Apr 10 at 13:47

Add a comment  |