多執行緒07：async、future、packaged_task、promise

?async、future、packaged_task、promise

本節內容需要包含標頭檔案：#include <future>

一、std::async、 std::future 建立後臺任務並返回值

①：啟用async

• std::async是一個函式模板，用來啟動一個非同步任務，啟動起來一個非同步任務之後，它返回一個std::future物件，這個物件是個類别範本。
• “啟動一個非同步任務”：就是自動建立一個執行緒，並開始 執行對應的執行緒入口函式，它返回一個std::future物件，這個std::future物件中就含有執行緒入口函式所返回的結果，我們可以通過呼叫future物件的成員函式get()來獲取結果。
• “future”將來的意思，也有人稱呼std::future提供了一種訪問非同步操作結果的機制，就是說這個結果你可能沒辦法馬上拿到，但是在不久的將來，這個執行緒執行完畢的時候，你就能夠拿到結果了，所以，大家這麼理解：future中儲存著一個值，這個值是在將來的某個時刻能夠拿到。
• std::future物件的get()成員函式會等待執行緒執行結束並返回結果，拿不到結果它就會一直等待，感覺有點像join()。但是，它是可以獲取結果的。並且記得一個future只能呼叫一次get（無論哪裡，都會將資料轉移），呼叫兩次程式會崩潰。
• std::future物件的wait()成員函式，用於等待執行緒返回，本身並不返回結果，這個效果和 std::thread 的join()更像。沒有隻能呼叫一次限制，但是呼叫多也沒有效果。
• 如果不呼叫future的get()成員函式和wait()成員函式，程式也會在主函式return處一直等待呼叫子執行緒結束；

看例子：

#include <iostream>
#include <future>
using namespace std;
class A {
public:
	int mythread(int data) {
		cout << data << endl;
		return data * 2;
	}
};
 
 
int mythread() {
	cout << "mythread() start" << "threadid = " << std::this_thread::get_id() << endl;
	std::chrono::milliseconds dura(5000);//睡5秒
	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; //卡在這裡等待mythread()執行完畢，拿到結果
	
	//類成員函式
	std::future<int> result2 = std::async(&A::mythread, &a, tmp); //第二個引數是物件引用才能保證執行緒裡執行的是同一個物件
	//cout << result2.get() << endl;//get()只能呼叫一次，result2不再有結果值，轉移的是存的資料型別，這裡是int！
   //或者result2.wait();
	cout << "finish all" << endl;
	return 0;
}

②：std::async的第一個引數

• 引數：std::launch::deferred: 表示執行緒入口函式呼叫被延遲到std::future的wait()或者get()函式呼叫時才執行； 那如果wait()或者get()沒呼叫，那麼執行緒沒執行！執行緒沒有建立！是在主執行緒中呼叫的執行緒入口函式！

#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; //卡在這裡等待mythread()執行完畢，拿到結果
	cout << "finish all" << endl;
	return 0;
}

• 引數：std::launch::async:在呼叫async函式的時候就開始建立執行緒；會強制std::async建立新執行緒，和thread一樣。
• 帶上兩個引數：std::launch::async |std::launch::deferred 這裡這個 |：以為這呼叫async的行為可能是 建立新執行緒並立即執行，或者沒有建立新執行緒並且延遲呼叫result.get()才開始執行任務入口函式，兩者居其一。（系統會自行決定是非同步（建立新執行緒）還是同步（不建立新執行緒）方式執行），預設值就是這個！

二、std::package_task

• 目的就是：打包任務，把任務包裝起來
• std::packaged_task是個模板類，它的模板引數是各種可呼叫物件（函式，函式指標，lambda表示式，bind建立的物件，以及過載了函式呼叫符的類,有點像function）；通過std::packaged_task來把各種可呼叫物件包裝起來，方便將來作為執行緒入口函式來呼叫。
• packaged_task包裝起來的可呼叫物件還可以直接呼叫，所以從這個角度來講，packaged_task物件，也是一個可呼叫物件。
• 看例子：

//可呼叫物件是普通函式
#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);//傳入真引用！不可以用detach模式
	t1.join();
	std::future<int> result = mypt.get_future(); 
	//std::future物件裡包含有執行緒入口函式的返回結果，這裡result儲存mythread返回的結果。
	cout << result.get() << endl;
   
	return 0;
}

//可呼叫物件是lambda表示式
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);//傳真引用，因為是packege_task,mypt只能再被呼叫一次
	t1.join();
	std::future<int> result = mypt.get_future(); 
	
	cout << result.get() << endl;
 
	cout << "finish overhead" << endl;
	return 0;
}

//呼叫物件是lambda表示式，直接呼叫
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);//也可以在主執行緒中直接呼叫，這樣就和function的效果一樣，但是隻能呼叫一次
	std::future<int> result = mypt.get_future(); 
	cout << result.get() << endl;
 
	cout << "finish overhead" << endl;
	return 0;
}

tip:瞭解ref

三、promise

• std::promise 類别範本，我們能夠在某個執行緒中給它賦值，然後我們可以在其他執行緒中把這個值取出來用;

• 總結：通過promise儲存一個值，在將來某時刻我們通過把一個future繫結到這個promise上來得到這個繫結的值；

#include<iostream>
#include<thread>
#include<mutex>
#include<future>
 
using namespace std;
 
void mythread(std::promise<int>&tmpp, int calc)
{
	//做一系列複雜的操作
	calc++;
	calc *= 10;
 
	//做其他運算，比如整整花費了5秒鐘
	std::chrono::milliseconds dura(5000); //定一個5秒的時間
	std::this_thread::sleep_for(dura);  //休息一定時常
 
	int result = calc; //儲存結果
	tmpp.set_value(result);  //####1.結果儲存到了tmpp這個promise物件中
} 
 
void mythread2(std::future<int> &tmpf) 
{
	auto result = tmpf.get();
	cout <<"mythread result = " << result<<endl;
}
 
int main()
{
	std::promise<int> myprom; //宣告一個std::promise物件myprom,儲存的值型別為int;
	std::thread t1(mythread,std::ref(myprom),180);
	t1.join();
 
	//獲取結果值
	std::future<int> fu1 = myprom.get_future();//####2.promise與future繫結，用於獲取執行緒返回值
 
	std::thread t2(mythread2,std::ref(fu1));
	t2.join(); //等mythread2執行完畢
 
	cout << "finish all"  << endl;
 	
    //fu1不再有用，已經為空；已經全部傳入mythread2的tmpf中，但是myprom還存著值1810；
	return 0;
}

//對於ref，package_task、future都會移動後原本的變數就沒有內容了，對於promise，卻還有，要探索一下

再瞭解async\future\等

四、std::asyn深入理解

4.1 std::async引數詳述

• 延遲呼叫引數 std::launch::deferred【延遲呼叫】，std::launch::async【強制建立一個執行緒】；

• std::async()我們一般不叫建立執行緒（他能夠建立執行緒），我們一般叫它建立一個非同步任務。std::async和std::thread最明顯的不同：就是 async 有時候並不建立新執行緒。

①如果用std::launch::deferred 來呼叫async？

延遲到呼叫 get() 或者 wait() 時執行，如果不呼叫就不會執行

②如果用std::launch::async來呼叫async？

強制這個非同步任務在新執行緒上執行，這意味著，系統必須要建立出新執行緒來執行入口函式。

③如果同時用 std::launch::async | std::launch::deferred

這裡這個 | 意味著async的行為可能是 std::launch::async 建立新執行緒立即執行， 也可能是 std::launch::deferred 沒有建立新執行緒並且延遲到呼叫get()執行，由系統根據實際情況來決定採取哪種方案

④不帶額外引數 std::async(mythread)，只給async 一個入口函式名，此時的系統給的預設值是 std::launch::async | std::launch::deferred 和 ③ 一樣，有系統自行決定非同步還是同步執行。

4.2 std::async和std::thread()區別

• std::thread()如果系統資源緊張可能出現建立執行緒失敗的情況，如果建立執行緒失敗那麼程式就可能崩潰，而且不容易拿到函式返回值（不是拿不到）
• std::async()建立非同步任務。可能建立執行緒也可能不建立執行緒，並且容易拿到執行緒入口函式的返回值；

由於系統資源限制：
①如果用std::thread建立的執行緒太多，則可能建立失敗，系統報告異常，崩潰。

②如果用std::async，一般就不會報異常，因為如果系統資源緊張，無法建立新執行緒的時候，async不加額外引數的呼叫方式就不會建立新執行緒。而是在後續呼叫get()請求結果時執行在這個呼叫get()的執行緒上。

如果你強制async一定要建立新執行緒就要使用 std::launch::async 標記。承受的代價是，系統資源緊張時可能崩潰。

③根據經驗，一個程式中執行緒數量 不宜超過100~200 。

4.3 async不確定性問題的解決

讓系統自行決定是否建立執行緒：std::future<int> result = std::async(mythread);問題焦點在於這個寫法，任務到底有沒有被推遲執行！

如何判斷：通過future中wait_for()方法的返回值；詳情看下一節內容

多閱讀高手程式碼，多積累，提升自己技術！