In C++11 and beyond, parallelism and asynchronous programming became a first‑class citizen of the language. The standard library provides two key abstractions for launching tasks asynchronously: std::async and std::future. These tools simplify the management of background operations, allow you to avoid blocking the main thread, and provide a clean mechanism to retrieve results or propagate exceptions. Below we explore how they work, common pitfalls, and best practices.
1. What is std::async?
std::async launches a function (or a callable object) potentially in a new thread and returns a std::future representing the eventual result. The function signature is:
template <class F, class... Args>
std::future<std::invoke_result_t<F, Args...>>
async(std::launch policy, F&& f, Args&&... args);The policy parameter controls when the task executes:
std::launch::async– guarantees a new thread will be started.std::launch::deferred– execution is postponed until thefutureis accessed.std::launch::async | std::launch::deferred– default, the implementation decides.
If you omit the policy, the default is the bitwise OR of both options.
2. Retrieving Results with std::future
A `std::future
` can be queried in two ways: – `future.get()` – blocks until the value is ready and returns it (or throws if the task threw an exception). – `future.wait()` or `future.wait_for()` – block only until the result is ready or a timeout occurs, returning a status. Once a `future` has been retrieved (via `get()`), it becomes invalid; calling `get()` again will result in `std::future_error`. ### 3. Example: Parallel Fibonacci “`cpp #include #include #include #include // Expensive recursive Fibonacci int fib(int n) { if (n <= 1) return n; std::this_thread::sleep_for(std::chrono::milliseconds(10)); // simulate work return fib(n-1) + fib(n-2); } int main() { std::future fut1 = std::async(std::launch::async, fib, 20); std::future fut2 = std::async(std::launch::async, fib, 21); std::cout << "Computing Fibonacci in parallel…\n"; int result = fut1.get() + fut2.get(); std::cout << "Result: " << result << '\n'; return 0; } “` In this example, two Fibonacci computations run concurrently, each in its own thread. The main thread blocks on `get()` until both results are ready. ### 4. Deferred Execution When you use `std::launch::deferred`, the task executes only when the future is queried: “`cpp auto deferred = std::async(std::launch::deferred, [](){ return 42; }); std::cout << "Deferred result: " << deferred.get() << '\n'; “` The call to `get()` triggers the function, and no thread is spawned. ### 5. Handling Exceptions If the asynchronous function throws, the exception is stored inside the `future`. When you call `get()`, the exception is rethrown: “`cpp auto fut = std::async([](){ throw std::runtime_error("oops"); }); try { fut.get(); } catch (const std::exception& e) { std::cerr << "Caught: " << e.what() << '\n'; } “` This mechanism enables clean error propagation across thread boundaries. ### 6. Cancellation and Timeouts Unlike some third‑party thread libraries, `std::async` offers no built‑in cancellation. If you need to stop a task prematurely, design the callable to periodically check a shared flag (e.g., `std::atomic `). For timeouts, combine `wait_for` with a cancellation token: “`cpp if (fut.wait_for(std::chrono::seconds(1)) == std::future_status::ready) { std::cout << "Result: " << fut.get() << '\n'; } else { std::cout << "Timed out!\n"; // optionally set cancellation flag } “` ### 7. Common Pitfalls | Pitfall | Explanation | Remedy | |———|————-|——–| | **Forgetting to join** | If the policy is `deferred`, the thread never starts, but if the program ends before `future.get()`, resources might leak. | Always call `get()` or `wait()` before the `future` goes out of scope. | | **Multiple `get()` calls** | After the first `get()`, the `future` is invalid. | Call `get()` only once. | | **Unbounded recursion** | Asynchronous tasks that spawn more async tasks can quickly exhaust system resources. | Limit recursion depth or use thread pools. | | **Deadlocks** | Mixing synchronous and asynchronous code incorrectly can block forever. | Use proper synchronization or redesign the flow. | ### 8. When to Use `std::async` – **Simple, single-task parallelism**: Launch a heavy computation and let the system decide whether to create a thread. – **Library design**: Provide an asynchronous interface to callers while hiding thread management. – **Quick prototyping**: Rapidly convert blocking code to non‑blocking. For more complex scenarios—e.g., many concurrent tasks, fine‑grained scheduling, or thread pools—consider `std::thread` with `std::async`‑style wrappers or third‑party libraries like Intel TBB, Microsoft PPL, or Boost.Asio. ### 9. Conclusion `std::async` and `std::future` give modern C++ programmers a lightweight, type‑safe way to perform asynchronous operations without boilerplate thread management. Understanding launch policies, result retrieval, exception handling, and limitations empowers you to write cleaner, more maintainable concurrent code. As you grow more comfortable, you can layer these primitives into higher‑level abstractions that fit your application's needs.