Why Does the Destructor of a `std::async` Future Block?

Why is the Destructor of a Future Returned from std::async Blocking?

In C 11, the destructor of a future returned by std::async blocks, leading to potential deadlocks. This behavior has sparked concern, prompting a series of proposals and discussions within the standardization committee.

The crux of the issue lies in ensuring thread safety. Without the blocking behavior, a situation could arise where an associated thread continues to execute after the future has been destroyed, leaving no way to synchronize its completion. This could result in memory corruption or even compromised system security.

As explained by Hans Boehm in N3679, this scenario is exacerbated by unhandled exceptions that may bypass code intended to wait for completion. Hence, the blocking destructor acts as a safety net, preventing such catastrophic outcomes.

Despite extensive deliberation, the C community has not reached a consensus on this matter. As of C 14, the destructors of std::future and std::thread remain blocking.

However, the situation may evolve in the future. Michael Wong's Trip Report from 2013 indicates that while the motion to deprecate std::async failed, there is a growing recognition of the potential hazard posed by its blocking behavior.

In the meantime, programmers should be aware of this issue and employ appropriate measures, such as scope guards or explicit synchronization mechanisms, to ensure thread safety when working with futures returned from std::async.

The above is the detailed content of Why Does the Destructor of a `std::async` Future Block?. For more information, please follow other related articles on the PHP Chinese website!