C++-std::packaged_task基本使用

packaged_task

std::packaged_task将一个future对象与函数或可调用对象相关联，当std::packaged_task对象被调用时，与之关联的函数或可调用对象被执行，执行结束后future对象变为ready状态并保存相关结果。传递给std::packaged_task的模板参数是函数签名，如void()或int(std::string&,double*)，而构造对象时传入的函数或可调用对象的参数和返回值必须一样或可转换为签名中对应的类型，如构造std::packaged_task<double(double)>类型的对象时可传入float func(int i)函数作为参数。

一个packaged_task<std::string(std::vector<char>*,int)>类型的类定义类似如下：

template<>
class packaged_task<std::string(std::vector<char>*,int)>
{
public:
    template<typename Callable>
    explicit packaged_task(Callable&& f);
    std::future<std::string> get_future();
    void operator()(std::vector<char>*,int);
};

其对象是一个可调用对象，参数与package_task模板参数中函数参数相同；get_future返回的future对象其模板参数为package_task模板参数中函数返回值类型。当packaged_task对象被调用时，其参数传入内部函数中，结果最终保存在与之关联的future对象中。

看个例子：

#include <deque>
#include <mutex>
#include <future>
#include <thread>
#include <utility>
std::mutex m;
std::deque<std::packaged_task<void()>> tasks;
bool gui_shutdown_message_received();
void get_and_process_gui_message();
void gui_thread()
{
    while (!gui_shutdown_message_received())
    {
        get_and_process_gui_message();
        std::packaged_task<void()> task;
        {
            std::lock_guard<std::mutex> lk(m);
            if (tasks.empty())
                continue;
            task = std::move(tasks.front());
            tasks.pop_front();
        }
        task();//2
    }
}
std::thread gui_bg_thread(gui_thread);
template <typename Func>
std::future<void> post_task_for_gui_thread(Func f)
{
    std::packaged_task<void()> task(f);//1
    std::future<void> res = task.get_future();
    std::lock_guard<std::mutex> lk(m);
    tasks.push_back(std::move(task));
    return res;
}

1处f是要执行的函数，我们将其作为参数构造了一个packaged_task对象，f返回的结果最终将保存在get_future返回的对象中，而tasks队列多个线程共享，gui_thread运行在另一个线程中，它不断从tasks队列中取出packaged_task对象，并执行调用运算符（2处），相当于执行f()。
我们注意到packaged_task将"任务"和"结果"分开了，任务即packaged_task对象，结果即get_future返回的future对象。packaged_task对象不能拷贝，只能移动（毕竟“拷贝任务”从语义上来说也很奇怪），因此tasks队列push和pop时都用到了std::move。

我们前一篇说到的async则更简单一些，它首先不是一个模板类型，而是一个函数，它的使用场景更像是“我有一个任务要后台运行/一会再运行，等我需要的时候我会从future中拿结果”，async调用时就默认创建了任务，但是我们拿不到这个具体的“任务”，任务执行的时间点要么是async调用的时候，要么是future::get/wait的时候，任务没法进行传递，而packaged_task对象就相当于“任务”，我们可以像上面一样在线程间传递并执行，并控制调用运算符函数的时机，其结果会自动保存到相应的future对象中。