The simplest way for asynchronous execution - std::async

Principle

std::async executes some piece of code in the background, possibly within a separate thread. Access to results (and waiting for thread execution) is possible via std::future.

Example

Asssume you have one or more time consuming calculations finally providing some result:

SomeResult CalculateSomething(int in_val)
{
    return ...
}

Then you can simply execute them asynchronously and in parallel by calling them via std::async. The result can be accesssed by use of a future.

#include<future>

{
    // Start 2 calculations in parallel
    std::future<SomeResult> calc1 = std::async(&CalculateSomething,17);
    std::future<SomeResult> calc2 = std::async(&CalculateSomething,42);

    // Do something else
    ...

    // Wait for the results
    SomeResult result1 = calc1.get();
    SomeResult result2 = calc2.get();
}

Remarks

• std::async decides on its own if really a separate thread is started. The decision may depend on the number of available processors and the number of already existing threads.
• instead of a function you can also use a function object or a lambda expression:

  SomeVal x;
  std::future calc3 = std::async([=]{return x*x*x;});

• Attention: Unwanted sequential execution.
  Do not forget to use the future instance to request the result. Otherwise the call of std::async will return a temporary future object which is immediatelly destroyed. Within destructor the future will wait for the termination of the asynchronous calculation. As a consequence the following actions are executed one after the other:

  // Sequential execution!
  std::async (&CalculateSomething,17);
  std::async (&CalculateSomething,42);

  For a more detailed discussion of problems with async and destructors of future and thread see Herb Sutter: async, ~future, and ~thread

std::async - most used features

You can provide an explicit start policy as first constructor argument for std::async:

Start policy	Description
std::launch::async	start separate execution thread
std::launch::deferred	start calculation in the same thread at the moment when result is requested via the future (lazy evaluation)

For more info see std::async - complete reference at CppReference.com