C++ 中 async、packaged_task、promise 区别及使用

Introduction

编程难,多线程编程更难 – 鲁迅

多线程编程,如此令人着迷、令人痛恨的字眼。人类为了追求更好的效率、更快的速度,非常残忍的发明了多线程编程,这不仅让写代码的难度陡增,同时也加快了头发掉落的速度,写到这时,我不禁感觉头上又凉了一些。

最近,我一脚踏进了 C++ 多线程编程的海洋中,在各种 std::threadstd::condition_variablestd::mutuxstd::unique_lockstd::async 等等中挣扎徘徊。并且,同事告诉我,这些小玩意只能算是餐前开胃菜,后面还有更棒棒的东西在等我,比如内存模型、无锁编程等等。听到着,我紧张地打开我的保温杯,多抓了一把枸杞放了进去。

饭要一点一点的吃,知识要一点一点的学。在学习过程中,我对 async、packated_task、promise 这仨的区别、以及应该在什么场景使用它们,都相当的困惑。在查阅了一些资料后,我按照个人理解总结了这篇文章。希望能够帮助到一些和我有一样疑问的小朋友们。当然,作为一名菜鸡,文章不可以避免会出现错误,也希望各位大佬指正。

使用方法

std::asyncstd::packaged_taskstd::promise 们都被安排在 《C++ Concurrency In Action》的 4.2 章,它们都能拿到一个 std::future。这些相似的地方是最初让我困惑地方,它们似乎有所区别,但是一开口却又具体说不上来。

我们先回顾下 std::asyncstd::packaged_taskstd::promise 的基本使用。首先从最直观的使用方式上来感受它们的差别。

std::async

当不着急要任务结果的时候,可以使用 std::async 启动一个异步任务,std::async 返回一个 std::future 对象,std::future 对象中存放着最终计算的结果。
一切都这么简单,这是获取 std::future 最简洁的方式。

当需要最终结果时,调用 std::future::get() 方法即可,该方法会阻塞线程直到期望值状态就绪为止。下面的代码是个简单例子:

#include <future>
#include <iostream>
int find_the_answer_to_ltuae();
void do_other_stuff();
int main()
{
    std::future<int> the_answer=std::async(find_the_answer_to_ltuae);
    do_other_stuff();
    std::cout<<"The answer is "<<the_answer.get()<<std::endl;
}

std::async 并不总会开启新的线程来执行任务,你可以指定 std::launch::async 来强制开启新线程

auto f = std::async(std::launch::async, func);

值得注意的是,std::future 析构函数会阻塞,直到线程结束。通常我们认为 std::future::get()std::future::wait() 才会阻塞,析构函数同样也会,这一点需要特别小心。

auto sleep = [](int s) { std::this_thread::sleep_for(std::chrono::seconds(s)); };
{
    auto f = std::async( std::launch::async, sleep, 5 ); // 开启一个异步任务,睡眠 5s
    // future 对象析构,等待睡眠结束
}

如果 std::future 被存放在一个临时对象中,那么std::async会立马阻塞,因为临时对象在返回后立马被析构了。例如下面的代码中将会阻塞 10s,但是如果加上 auto f = 那么只会阻塞 5s

auto sleep = [](int s) { std::this_thread::sleep_for(std::chrono::seconds(s)); };

{
    std::async( std::launch::async, sleep, 5 ); // 临时对象被析构,阻塞 5s
    std::async( std::launch::async, sleep, 5 ); // 临时对象被析构,阻塞 5s
    
    //auto f1 = std::async( std::launch::async, sleep, 5 );
    //auto f2 = std::async( std::launch::async, sleep, 5 );
}

std::packaged_task

std::packaged_task 本身和线程没啥关系,它只是一个关联了 std::future 的仿函数。看下面这个例子:

auto task = [](int i) { 
std::this_thread::sleep_for(std::chrono::seconds(5)); return i+100; 
};

std::packaged_task< int(int) > package{ task };
std::future<int> f = package.get_future();
package(1);
std::cout << f.get() << "\n";

我们调用 package(1) 就开始执行函数,就像执行了 task(1) 一样。运行结束后,f 已经处在就绪转态,因此 .get() 并不会阻塞。

因为 std::packaged_task 是个仿函数,我们用它来创建 std::thread,并通过 std::future 来获取运行的结果,看这个例子:

std::packaged_task< int(int) > package{ task };
std::future<int> f = package.get_future();
std::thread t { std::move(package), 5 };

std::cout << f.get() << std::endl; // 阻塞,直到线程 t 结束

t.join();

可以看到,std:packaged_task 的使用稍微麻烦一些,需要显式的调用或者传递给std::thread进行异步调用,但其具有更加灵活的控制调用方式,并且可以选择什么时间开始任务,而 std::async 则是一旦调用立马开始执行,并且直接调用 std::async()中临时变量析构的导致阻塞的坑,std::packaged_task 没有。

需要注意的是,一定过一定要在调用 f.get() 之前,执行了 std::packaged_task,否则你的程序会一直阻塞在那:

std::packaged_task<int(int,int)> task(...);
auto f = task.get_future();
std::cout << f.get() << "\n"; // oops!
task(2,3);

std::promise

std::promise 是一种非常强大的机制。例如,你可以将一个值传递给新进程,而不需要任何额外的同步操作。

auto task = [](std::future<int> i) {
    std::cout << i.get() << std::flush; // 阻塞,直到 p.set_value() 被调用
};

std::promise<int> p;
std::thread t{ task, p.get_future() };

std::this_thread::sleep_for(std::chrono::seconds(5));
p.set_value(5);

t.join();

自顶向下

介绍完如何使用,现在我们来思考 std::asyncstd::packaged_taskstd::promise 之间的关系。总体来说,std::async 接口最简单,做的事情最多,抽象程度最高;std::packaged_task,抽象程度次之,需要额外的操作但却比较灵活;std::promise 功能最为单一,是三者中抽象程度最低的。

我们用 std::packaged_task 来实现 std::async 的功能:

std::future<int> my_async(function<int(int i)> task, int i)
{
    std::packaged_task<int(int)> package{task};
    std::future<int> f = package.get_future();

    std::thread t(std::move(package), i);
    t.detach();
    return f;
}

int main()
{
    auto task = [](int i) { std::this_thread::sleep_for(std::chrono::seconds(5)); return i+100; };

    std::future<int> f = my_async(task, 5);
    std::cout << f.get() << std::endl;
    return 0;
}

在 0 处通过 std::packaged_task::get_future 获得一个 std::future 用于返回;1 处我们将std::packaged_task 用新线程启动,等于 std::async 中使用了 std::launch::async 参数; 在 2 处,无需等待新线程运行结束,因此直接.detach() 线程。可以看到,std::packaged_task 完全可以实现 std::async 的全部功能,并且返回的 std::future 并不会在析构的时候阻塞。

接下来我们用 std::promise 来实现 std::packaged_task

template <typename> class my_task;

template <typename R, typename ...Args>
class my_task<R(Args...)>
{
    std::function<R(Args...)> fn;
    std::promise<R> pr;             // the promise of the result
public:
    template <typename ...Ts>
    explicit my_task(Ts &&... ts) : fn(std::forward<Ts>(ts)...) { }

    template <typename ...Ts>
    void operator()(Ts &&... ts)
    {
        pr.set_value(fn(std::forward<Ts>(ts)...));  // fulfill the promise
    }

    std::future<R> get_future() { return pr.get_future(); }

    // disable copy, default move
};

这个简易版的 my_taskstd::packaged_task 使用上没啥区别,内部用了 std::promise 来获取 std::future,在 operator() 中通过 std_value() 方法来传递数据,让 std::future 处于就绪状态。

总结

通过上面的描述,你应该对如何使用,以及它们之间的层级关系有一定了解了。总结一下:

  • std::async 来做简单的事情,例如异步执行一个任务。但是要注意 std::future 析构阻塞的问题。
  • std::packaged_task 能够很轻松的拿到 std::future,选择是否配合 std::thread 进行异步处理。同时没有析构阻塞的问题。
  • std::promise 是三者中最底层的能力,可以用来同步不同线程之间的消息

C++ 中 async、packaged_task、promise 区别及使用

评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值