C++:std::async 和 std::mutex 在 Linux 上导致死锁但在 Windows 上运行？

Question

我刚刚为 Linux 编译了一个我一直在 Windows 下工作的项目，发现它在某个点挂起。由于我使用 std::async 和 std::mutex 我的第一个假设是，这可能是一个死锁问题。但是，我想知道为什么它在 Windows 上运行良好。这是代码:

void BorderExtractor::preprocessImageAsync(const PreprocessingSettings& settings) {
    _preprocessingMutex.lock();
    if (!_preprocessingActive) {
        _preprocessingActive = true;
        std::async(std::launch::async, &BorderExtractor::preprocessImage, this, settings);
        //this point is never reached on linux
        _preprocessingUpToDate = true;
    } else {
        _cachedSettings = settings;
        _preprocessingUpToDate = false;
    }
    _preprocessingMutex.unlock();
}

这是Linux下永不返回的函数。它一直运行到异步调用，然后才停止。它几乎看起来好像函数不是异步启动的，程序等待它返回，这是行不通的，因为另一个函数将尝试锁定同一个互斥量。

这是异步调用的函数:

void BorderExtractor::preprocessImage(PreprocessingSettings settings) {

    //here some image processing stuff is done

    _preprocessingMutex.lock();
    //this point is never reached on linux
    if (!_preprocessingUpToDate) {
        _preprocessingUpToDate = true;
        _preprocessingMutex.unlock();
        std::async(std::launch::async, &BorderExtractor::preprocessImage, this, _cachedSettings);
    } else {
        _preprocessingUpToDate = true;
        _preprocessingActive = false;
        _preprocessingMutex.unlock();
    }
}

在 linux 下永远不会达到它尝试锁定互斥锁之后的那个点。

现在，问题是什么？是我的代码有问题，还是在 Linux 上有什么特别需要注意的地方？ (编译器标志等)对我来说，这似乎是异步调用是同步的，因此会导致死锁。但为什么会这样

Answer 1

这个调用:

async(std::launch::async, &BorderExtractor::preprocessImage, this, _cachedSettings);

有效地同步运行。这是因为 std::async() 返回的 std::future 的析构函数最终加入了异步计算 - 注意，行为如果你以其他方式获得 future ，那就不一样了。

因为你没有让 std::async 返回的 future 对象保持事件状态，它的生命周期在函数调用返回后立即结束，并且它的析构函数阻塞直到异步计算终止 - 这是永远的，因为这似乎会导致僵局。

这在 Windows 上工作的原因可能是因为您使用的是标准库的不兼容实现(例如 VS2013 附带的 Microsoft 实现)，其中 future 的析构函数不加入异步计算 - MS 有意这样做，遵循 this (rejected) proposal by Herb Sutter 中说明的基本原理.

如果您正在寻找一种即发即弃的方法，请考虑 this alternative implementation of std::async() ，这不会导致返回的 future 阻止销毁(由 bamboon 提供):

template<class Function, class... Args>
std::future<typename std::result_of<Function(Args...)>::type> async( 
    Function&& f, 
    Args&&... args) 
{
    using R = typename std::result_of<Function(Args...)>::type;
    auto bound_task = std::bind(std::forward<Function>(f), std::forward<Args>(args)...);
    auto task = std::packaged_task<R()>{std::move(bound_task)};
    auto ret = task.get_future();
    auto t = std::thread{std::move(task)};
    t.detach();
    return ret;   
}

作为旁注，避免显式锁定/解锁互斥量。相反，使用 RAII 包装器，如 std::lock_guard 或(如有必要)std::unique_lock 以确保即使抛出异常或以防万一，你的互斥锁也会被解锁提前返回:

// The mutex will be unlocked automatically when the function returns.
std::lock_guard<std::mutex> lock{_preprocessingMutex};

if (!_preprocessingUpToDate) {
    _preprocessingUpToDate = true;
    async(std::launch::async, &BorderExtractor::preprocessImage, this, _cachedSettings);
    // No need to call unlock() on the mutex!
} else {
    _preprocessingUpToDate = true;
    _preprocessingActive = false;
    // No need to call unlock() on the mutex!
}