stdasync

std::async is a function template in the C++ standard library, declared in the <future> header, that runs a callable asynchronously and returns a std::future representing the eventual result. It was introduced in the C++11 standard and is designed to provide a convenient way to perform work concurrently without managing threads directly.

The function accepts a callable and its arguments and returns a future of the result type. Two launch policies control how the task is executed: std::launch::async, which may start the task in a new thread, and std::launch::deferred, which defers execution until the future is queried or waited on. If neither policy is specified, the implementation may choose between asynchronous execution and deferred evaluation. The task is guaranteed to be invoked exactly once when it is eventually executed, and the future communicates the result or any exception back to the caller.

The return type is a std::future<T>, where T is the result type of invoking the callable with the provided arguments. The callable is invoked with forwarded arguments, and the future becomes ready when the callable completes. If the callable throws, the exception is captured by the future and will be rethrown when get() is called. If a thread cannot be started for asynchronous execution, an exception such as std::system_error may be thrown.

Usage notes and caveats include the overhead of creating asynchronous tasks and the fact that std::async is not a portable, direct replacement for a thread pool. The behavior of the launch policy may vary by standard library implementation, and excessive use can lead to resource contention. It is commonly used to initiate parallel work and later synchronize via future::get or future::wait.

See also: future, promise, thread, launch policy.