上一篇介紹的std::promise通過set_value可以使得與之關聯(lián)的std::future獲取數(shù)據。本篇介紹的std::packaged_task則更為強大，它允許傳入一個函數(shù)，并將函數(shù)計算的結果傳遞給std::future，包括函數(shù)運行時產生的異常。下面我們就來詳細介紹一下它。

2. std::package_task

在開始std::packaged_task之前我們先看一段代碼，對std::packaged_task有個直觀的印象，然后我們再進一步介紹。

#include <thread>   // std::thread
#include <future>   // std::packaged_task, std::future
#include <iostream> // std::cout

int sum(int a, int b) {
    return a + b;
}

int main() {
    std::packaged_task<int(int,int)> task(sum);
    std::future<int> future = task.get_future();

    // std::promise一樣，std::packaged_task支持move，但不支持拷貝
    // std::thread的第一個參數(shù)不止是函數(shù)，還可以是一個可調用對象，即支持operator()(Args...)操作
    std::thread t(std::move(task), 1, 2);
    // 等待異步計算結果
    std::cout << "1 + 2 => " << future.get() << std::endl;

    t.join();
    return 0;
}
/// 輸出: 1 + 2 => 3

std::packaged_task位于頭文件#include <future>中，是一個模板類

template <class R, class... ArgTypes>
class packaged_task<R(ArgTypes...)>

其中R是一個函數(shù)或可調用對象，ArgTypes是R的形參。與std::promise一樣，std::packaged_task支持move，但不支持拷貝(copy)。std::packaged_task封裝的函數(shù)的計算結果會通過與之聯(lián)系的std::future::get獲取(當然，可以在其它線程中異步獲取)。關聯(lián)的std::future可以通過std::packaged_task::get_future獲取到，get_future僅能調用一次，多次調用會觸發(fā)std::future_error異常。
std::package_task除了可以通過可調用對象構造外，還支持缺省構造(無參構造)。但此時構造的對象不能直接使用，需通過右值賦值操作設置了可調用對象或函數(shù)后才可使用。判斷一個std::packaged_task是否可使用，可通過其成員函數(shù)valid來判斷。

2.1 std::packaged_task::valid

該函數(shù)用于判斷std::packaged_task對象是否是有效狀態(tài)。當通過缺省構造初始化時，由于其未設置任何可調用對象或函數(shù)，valid會返回false。只有當std::packaged_task設置了有效的函數(shù)或可調用對象，valid才返回true。

#include <future>   // std::packaged_task, std::future
#include <iostream> // std::cout

int main() {
    std::packaged_task<void()> task; // 缺省構造、默認構造
    std::cout << std::boolalpha << task.valid() << std::endl; // false

    std::packaged_task<void()> task2(std::move(task)); // 右值構造
    std::cout << std::boolalpha << task.valid() << std::endl; // false

    task = std::packaged_task<void()>([](){});  // 右值賦值, 可調用對象
    std::cout << std::boolalpha << task.valid() << std::endl; // true

    return 0;
}

上面的示例演示了幾種valid為false的情況，程序輸出如下

false
false
true

2.2 std::packaged_task::operator()(ArgTypes...)

該函數(shù)會調用std::packaged_task對象所封裝可調用對象R，但其函數(shù)原型與R稍有不同:

void operator()(ArgTypes... );

operator()的返回值是void，即無返回值。因為std::packaged_task的設計主要是用來進行異步調用，因此R(ArgTypes...)的計算結果是通過std::future::get來獲取的。該函數(shù)會忠實地將R的計算結果反饋給std::future，即使R拋出異常(此時std::future::get也會拋出同樣的異常)。

#include <future>   // std::packaged_task, std::future
#include <iostream> // std::cout

int main() {
    std::packaged_task<void()> convert([](){
        throw std::logic_error("will catch in future");
    });
    std::future<void> future = convert.get_future();

    convert(); // 異常不會在此處拋出

    try {
        future.get();
    } catch(std::logic_error &e) {
        std::cerr << typeid(e).name() << ": " << e.what() << std::endl;
    }

    return 0;
}
/// Clang下輸出: St11logic_error: will catch in future

為了幫忙大家更好的了解該函數(shù)，下面將Clang下精簡過的operator()(Args...)的實現(xiàn)貼出，以便于更好理解該函數(shù)的邊界，明確什么可以做，什么不可以做。

template<class _Rp, class ..._ArgTypes>
class packaged_task<_Rp(_ArgTypes...)> {
    __packaged_task_function<_Rp_(_ArgTypes...)> __f_;
    promise<_Rp> __p_;  // 內部采用了promise實現(xiàn)

public:
    // 構造、析構以及其它函數(shù)...

    void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) {
        if (__p_.__state_ == nullptr)
            __throw_future_error(future_errc::no_state);
        if (__p_.__state_->__has_value())  // __f_不可重復調用
            __throw_future_error(future_errc::promise_already_satisfied);

        try {
            __p_.set_value(__f_(std::forward<_ArgTypes>(__args)...));
        } catch (...) {
            __p_.set_exception(current_exception());
        }
    }
};

2.3 讓std::packaged_task在線程退出時再將結果反饋給std::future

std::packaged_task::make_ready_at_thread_exit函數(shù)接收的參數(shù)與operator()(_ArgTypes...)一樣，行為也一樣。只有一點差別，那就是不會將計算結果立刻反饋給std::future，而是在其執(zhí)行時所在的線程結束后，std::future::get才會取得結果。

2.4 std::packaged_task::reset

與std::promise不一樣， std::promise僅可以執(zhí)行一次set_value或set_exception函數(shù)，但std::packagged_task可以執(zhí)行多次，其奧秘就是reset函數(shù)

template<class _Rp, class ..._ArgTypes>
void packaged_task<_Rp(_ArgTypes...)>::reset()
{
    if (!valid())
        __throw_future_error(future_errc::no_state);
    __p_ = promise<result_type>();
}

通過重新構造一個promise來達到多次調用的目的。顯然調用reset后，需要重新get_future，以便獲取下次operator()執(zhí)行的結果。由于是重新構造了promise，因此reset操作并不會影響之前調用的make_ready_at_thread_exit結果，也即之前的定制的行為在線程退出時仍會發(fā)生。

std::packaged_task就介紹到這里，下一篇將會完成本次異步運行的整體脈絡，將std::async和std::future一起介紹結大家。

附: C++11多線程中的樣例代碼的編譯及運行

g++ -std=c++11 <Your Cpp File>
./a.out