http://www.cnblogs.com/haippy/p/3279565.html

#include <iostream>     // std::cout

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

#include <chrono>       // std::chrono::seconds

#include <thread>       // std::thread, std::this_thread::sleep_for

// count down taking a second for each value:

int countdown (int from, int to) {

    for (int i=from; i!=to; --i) {

        std::cout << i << '\n';

        std::this_thread::sleep_for(std::chrono::seconds());

    }

    std::cout << "Finished!\n";

    return from - to;

}

int main ()

{

    std::packaged_task<int(int,int)> task(countdown); // 设置 packaged_task

    std::future<int> ret = task.get_future(); // 获得与 packaged_task 共享状态相关联的 future 对象.

    std::thread th(std::move(task), , );   //创建一个新线程完成计数任务.

    int value = ret.get();                    // 等待任务完成并获取结果.

    std::cout << "The countdown lasted for " << value << " seconds.\n";

    th.join();

    return ;

}

#include <iostream>     // std::cout

#include <utility>      // std::move

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

#include <thread>       // std::thread

int main ()

{

    std::packaged_task<int(int)> foo; // 默认构造函数.

    // 使用 lambda 表达式初始化一个 packaged_task 对象.

    std::packaged_task<int(int)> bar([](int x){return x*;});

    foo = std::move(bar); // move-赋值操作，也是 C++11 中的新特性.

    // 获取与 packaged_task 共享状态相关联的 future 对象.

    std::future<int> ret = foo.get_future();

    std::thread(std::move(foo), ).detach(); // 产生线程，调用被包装的任务.

    int value = ret.get(); // 等待任务完成并获取结果.

    std::cout << "The double of 10 is " << value << ".\n";

return ;

}

#include <iostream>     // std::cout

#include <utility>      // std::move

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

#include <thread>       // std::thread

// a simple task:

int triple(int x) { return x * ; }

int main()

{

    std::packaged_task<int(int)> tsk(triple); // package task

    std::future<int> fut = tsk.get_future();

    std::thread(std::ref(tsk), ).detach();

    std::cout << "The triple of 100 is " << fut.get() << ".\n";

    // re-use same task object:

    tsk.reset();

    fut = tsk.get_future();

    std::thread(std::move(tsk), ).detach();

    std::cout << "Thre triple of 200 is " << fut.get() << ".\n";

    return ;

}

#include <iostream>       // std::cout

#include <future>         // std::async, std::future, std::shared_future

int do_get_value() {

    std::this_thread::sleep_for(std::chrono::seconds());

    return ; }

int main()

{

    std::future<int> fut = std::async(do_get_value);

    std::shared_future<int> shared_fut = fut.share();

    // 共享的 future 对象可以被多次访问.

    cout << "--1--" << endl;

    std::cout << "value: " << shared_fut.get() << '\n';

    cout << "--2--" << endl;

    std::cout << "its double: " << shared_fut.get() *  << '\n';

    cout << "--3--" << endl;

    return ;

}