第九节、async、future、packaged_task、promise
本节内容需要包含头文件#include
一、std::async、std::future创建后台任务并返回值
std::async是一个函数模板,用来启动一个异步任务,启动起来一个异步任务之后,它返回一个std::future对象,这个对象是个类模板。
什么叫“启动一个异步任务”?就是自动创建一个线程,并开始 执行对应的线程入口函数,它返回一个std::future对象,这个std::future对象中就含有线程入口函数所返回的结果,我们可以通过调用future对象的成员函数get()来获取结果。
“future”将来的意思,也有人称呼std::future提供了一种访问异步操作结果的机制,就是说这个结果你可能没办法马上拿到,但是在不久的将来,这个线程执行完毕的时候,你就能够拿到结果了,所以,大家这么理解:future中保存着一个值,这个值是在将来的某个时刻能够拿到。
std::future对象的get()成员函数会等待线程执行结束并返回结果,拿不到结果它就会一直等待,感觉有点像join()但是,它是可以获取结果的。
std::future对象的wait()成员函数,用于等待线程返回,本身并不返回结果,这个效果和 std::thread 的join()更像。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
| #include <iostream> #include <future> using namespace std; class A { public: int mythread(int mypar) { cout << mypar << endl; return mypar; } }; int mythread() { cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; return 5; } int main() { A a; int tmp = 12; cout << "main" << "threadid = " << std::this_thread::get_id() << endl; std::future<int> result1 = std::async(mythread); cout << "continue........" << endl; cout << result1.get() << endl; std::future<int> result2 = std::async(&A::mythread, &a, tmp); cout << result2.get() << endl; cout << "good luck" << endl; return 0; }
|
我们通过向std::async()传递一个参数,改参数是std::launch类型(枚举类型),来达到一些特殊的目的:
1、std::lunch::deferred:
(defer推迟,延期)表示线程入口函数的调用会被延迟,一直到std::future的wait()或者get()函数被调用时(由主线程调用)才会执行;如果wait()或者get()没有被调用,则不会执行。
实际上根本就没有创建新线程。std::lunch::deferred意思时延迟调用,并没有创建新线程,是在主线程中调用的线程入口函数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| #include <iostream> #include <future> using namespace std; int mythread() { cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; return 5; } int main() { cout << "main" << "threadid = " << std::this_thread::get_id() << endl; std::future<int> result1 = std::async(std::launch::deferred ,mythread); cout << "continue........" << endl; cout << result1.get() << endl; cout << "good luck" << endl; return 0; }
|
永远都会先打印出continue……..,然后才会打印出mythread() start和mythread() end等信息。
2、std::launch::async,在调用async函数的时候就开始创建新线程。
1 2 3 4 5 6 7 8
| int main() { cout << "main" << "threadid = " << std::this_thread::get_id() << endl; std::future<int> result1 = std::async(std::launch::async ,mythread); cout << "continue........" << endl; cout << result1.get() << endl; cout << "good luck" << endl; return 0; }
|
二、std::packaged_task:打包任务,把任务包装起来。
类模板,它的模板参数是各种可调用对象,通过packaged_task把各种可调用对象包装起来,方便将来作为线程入口函数来调用。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
| #include <thread> #include <iostream> #include <future> using namespace std; int mythread(int mypar) { cout << mypar << endl; cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; return 5; } int main() { cout << "main" << "threadid = " << std::this_thread::get_id() << endl; //我们把函数mythread通过packaged_task包装起来 //参数是一个int,返回值类型是int std::packaged_task<int(int)> mypt(mythread); std::thread t1(std::ref(mypt), 1); t1.join(); std::future<int> result = mypt.get_future(); //std::future对象里包含有线程入口函数的返回结果,这里result保存mythread返回的结果。 cout << result.get() << endl; return 0; }
|
可调用对象可由函数换成lambda表达式
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| int main() { cout << "main" << "threadid = " << std::this_thread::get_id() << endl; std::packaged_task<int(int)> mypt([](int mypar) { cout << mypar << endl; cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; return 5; }); std::thread t1(std::ref(mypt), 1); t1.join(); std::future<int> result = mypt.get_future(); //std::future对象里包含有线程入口函数的返回结果,这里result保存mythread返回的结果。 cout << result.get() << endl; cout << "good luck" << endl; return 0; }
|
packaged_task包装起来的可调用对象还可以直接调用,从这个角度来讲,packaged_task对象也是一个可调用对象
lambda的直接调用
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
| int main() { cout << "main" << "threadid = " << std::this_thread::get_id() << endl; std::packaged_task<int(int)> mypt([](int mypar) { cout << mypar << endl; cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; return 5; }); mypt(1); std::future<int> result = mypt.get_future(); cout << result.get() << endl; }
|
std::promise,类模板
我们能够在某个线程中给它赋值,然后我们可以在其他线程中,把这个值取出来
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
| #include <thread> #include <iostream> #include <future> using namespace std; void mythread(std::promise<int> &tmp, int clac) { cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl; std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); cout << "mythread() end" << "threadid = " << std::this_thread::get_id() << endl; int result = clac; tmp.set_value(result); //结果保存到了tmp这个对象中 return; } vector<std::packaged_task<int(int)>> task_vec; int main() { std::promise<int> myprom; std::thread t1(mythread, std::ref(myprom), 180); t1.join(); //在这里线程已经执行完了 std::future<int> fu1 = myprom.get_future(); //promise和future绑定,用于获取线程返回值 auto result = fu1.get(); cout << "result = " << result << endl; }
|
总结:通过promise保存一个值,在将来某个时刻我们通过吧一个future绑定到这个promise上,来得到绑定的值
注意:使用thread时,必须 join() 或者 detach() 否则程序会报异常
小结:
我们学习这些东西的目的并不是,要把他们都用到实际开发中。
相反,如果我们能够用最少的东西写出一个稳定的,高效的多线程程序,更值得赞赏。
我们为了成长必须阅读一些高手写的代码,从而实现自己代码的积累;