Question

有几次我被告知，我应该使用std::async作为火＆amp;忘记使用std::launch::async参数的任务类型（因此它最好在新的执行线程上发挥作用）。

在这些陈述的鼓励下，我想看看std::async与以下内容的比较：

顺序执行
一个简单的分离std::thread
我简单的异步“实现”

我天真的异步实现如下所示：

template <typename F, typename... Args>
auto myAsync(F&& f, Args&&... args) -> std::future<decltype(f(args...))>
{
    std::packaged_task<decltype(f(args...))()> task(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    auto future = task.get_future();

    std::thread thread(std::move(task));
    thread.detach();

    return future;
}

这里没什么好看的，将仿函数f与其参数一起打包到std::packaged task中，在分离的新std::thread上启动它，然后返回std::future来自任务。

现在代码用std::chrono::high_resolution_clock测量执行时间：

int main(void)
{
    constexpr unsigned short TIMES = 1000;

    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < TIMES; ++i)
    {
        someTask();
    }
    auto dur = std::chrono::high_resolution_clock::now() - start;

    auto tstart = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < TIMES; ++i)
    {
        std::thread t(someTask);
        t.detach();
    }
    auto tdur = std::chrono::high_resolution_clock::now() - tstart;

    std::future<void> f;
    auto astart = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < TIMES; ++i)
    {
        f = std::async(std::launch::async, someTask);
    }
    auto adur = std::chrono::high_resolution_clock::now() - astart;

    auto mastart = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < TIMES; ++i)
    {
        f = myAsync(someTask);
    }
    auto madur = std::chrono::high_resolution_clock::now() - mastart;

    std::cout << "Simple: " << std::chrono::duration_cast<std::chrono::microseconds>(dur).count() <<
    std::endl << "Threaded: " << std::chrono::duration_cast<std::chrono::microseconds>(tdur).count() <<
    std::endl << "std::sync: " << std::chrono::duration_cast<std::chrono::microseconds>(adur).count() <<
    std::endl << "My async: " << std::chrono::duration_cast<std::chrono::microseconds>(madur).count() << std::endl;

    return EXIT_SUCCESS;
}

someTask()是一个简单的方法，我稍等一下，模拟完成的一些工作：

void someTask()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
}

最后，我的结果：

顺序：1263615
螺纹：47111
std :: sync：821441
我的异步：30784

任何人都可以解释这些结果吗？似乎std::aysnc比我的幼稚实施更强，或者仅仅是简单的分离的 std::thread。 为什么是这样的？在这些结果之后有任何理由使用std::async吗？

（注意我也用clang ++和g ++做了这个基准测试，结果非常相似）

更新

在阅读Dave S的回答后，我将我的小基准更新如下：

std::future<void> f[TIMES]; auto astart = std::chrono::high_resolution_clock::now(); for (int i = 0; i < TIMES; ++i) { f[i] = std::async(std::launch::async, someTask); } auto adur = std::chrono::high_resolution_clock::now() - astart;

所以std::future现在没有被破坏 - 因此加入 - 每次运行。在代码中进行此更改后，std::async会对我的实现产生类似的结果。分离的std::thread s。

Answer 1

一个关键的区别是async返回的未来在未来被销毁时加入线程，或者在你的情况下，用新值替换。

这意味着它必须执行someTask()并加入线程，这两者都需要时间。你的其他测试都没有这样做，他们只是独立地生成它们。

Answer 2

sts::async会返回一个特殊的std::future。这个未来的~future可以.wait()。

所以你的例子根本不同。慢的实际上在你的时间执行任务。快速的只是排队任务，忘记如何知道任务完成。由于让线程超过main结尾的程序行为是不可预测的，因此应该避免使用它。

比较任务的正确方法是在生成时存储生成的future，并在计时器结束之前.wait() / .join()，或者避免破坏对象直到之后计时器到期。然而，最后一种情况使得sewuential版本看起来比它更糟糕。

您需要在开始下一次测试之前加入/等待，否则您将从他们的时间中窃取资源。

请注意，移动的期货会从源中删除等待。

与简单的分离线程相比，为什么std :: async会变慢？

2 个答案: