在对象

Question

我将std::async包裹在类似于此的类中：

class AsyncTask
{
public:
    AsyncTask() {}
    ~AsyncTask()
    {
        m_shouldTerminate.store(true, std::memory_order::memory_order_release);
    }

    std::future<int> runAsync()
    {
        return std::async(std::launch::async, [this]() { threadMain(); return m_result; });
    }

private:
    void threadMain()
    {
        for(int i=0; i<std::numeric_limits<int>::max(); ++i)
        {
            if (m_shouldTerminate.load(std::memory_order::memory_order_acquire))
            {
                break;
            }

            // do time consuming calculation but abort if m_shouldTerminate becomes true
            m_result += foo([this]() { return m_shouldTerminate.load(std::memory_order::memory_order_acquire); });
        }
    }

    int m_result = 0;
    std::atomic<bool> m_shouldTerminate = false;
};

如果未来从std::future::~future返回，则AFAIK std::async会屏蔽。对于像

这样的代码，这意味着

{
    AsyncTask myTask;
    myTask.runAsync();
}

bar();

它会在临时未来的析构函数中阻塞，然后破坏myTask，然后才会调用bar()。考虑到这一点，应确保任何AsyncTask对象的生命周期超过任务本身的运行时间，并且我的实现应该是安全的。

如果动态分配AsyncTask，显然这个保证将不再成立。

我的假设是否正确是我的实施安全吗？特别是当异步任务仍在运行时，AsyncTask对象可能会被销毁吗？