C++11線程異步-創(chuàng)新互聯(lián)

文章目錄
    • 1. 線程異步的概念
    • 2. future
      • 2.1 共享狀態(tài)
      • 2.2 常用成員函數(shù)
    • 3. promise
      • 3.1 常用成員函數(shù)
      • 3.2 promise的基本使用
    • 4. package_task
      • 4.1 常用成員函數(shù)
      • 4.2 package_task的基本使用
    • 5. async
      • 5.1 async的基本使用
    • 6. promise、package_task、async的對比與總結

創(chuàng)新互聯(lián)為企業(yè)級客戶提高一站式互聯(lián)網(wǎng)+設計服務，主要包括成都網(wǎng)站建設、做網(wǎng)站、手機APP定制開發(fā)、微信小程序開發(fā)、宣傳片制作、LOGO設計等，幫助客戶快速提升營銷能力和企業(yè)形象，創(chuàng)新互聯(lián)各部門都有經(jīng)驗豐富的經(jīng)驗，可以確保每一個作品的質量和創(chuàng)作周期，同時每年都有很多新員工加入，為我們帶來大量新的創(chuàng)意。 1. 線程異步的概念

問題1: 如何理解線程異步?

?異步的反義詞是同步。異步與同步的區(qū)別見此處: [[Linux/計算機網(wǎng)絡基礎知識點/高級IO#同步通信 vs 異步通信]]。實際上在多線程下，大部分時候都是存在過異步這一狀態(tài)的。主線程在創(chuàng)建了子線程后，也去干自己的任務了。

問題2: 線程異步的應用場景?

  1. 主線程想要得到某一子線程運行的任務函數(shù)的運行結果。這里的結果可以使用future對象進行存儲。(future是個模板類, 能存儲任意類型, 包括void)//子—>主
  2. 主線程想要通知子線程, 依靠future值和狀態(tài) 來達成某一目的(讓子線程結束/滿足條件/…), 此時主線程在外面設置future對象的共享狀態(tài)及future值。子線程那邊可以根據(jù)future對象的狀態(tài)和值進行一些邏輯判斷然后到達想要的結果。//主—>子

?

2. future
//包含于頭文件
templatefuture;
templatefuture;     // specialization : T is a reference type (R&)
template<> future;   // specialization : T is void
//---------------------------------------------------
//構造函數(shù)
future() noexcept;					//(1) default
future (const future&) = delete;	//(2) copy [deleted]
future (future&& x) noexcept;		//(3) move

//賦值
future& operator=(future&& other) noexcept;
future& operator=(const future& other) = delete;

?
?future對象是用于存儲某一類型的值的，只不過這個值往往是在未來才能獲取到。 它被用來作為線程異步的中間存儲值。future的值由以下三個異步任務的提供者(Provider)提供:

  1. std::promise
  2. std::package_task
  3. std::async

?我們根據(jù)future的構造函數(shù)可以發(fā)現(xiàn)，future不支持拷貝構造。future的operator=()會去調用移動構造。

?

2.1 共享狀態(tài)

?future在線程異步當中扮演的是一個被動角色。它需要與promise、package_task、async配合來實現(xiàn)線程異步。由于它必須要進行共享關聯(lián)，因此future對象時存在共享狀態(tài)是否有效的問題的。只有共享狀態(tài)有效，才能獲取future的值。

?future對象是有"共享狀態(tài)"這一概念的。共享狀態(tài)必須依靠上面提到的三者對應的方法:promise::get_future()、package_task::get_future()、async()獲取。否則單純的創(chuàng)建一個future對象, 它的共享狀態(tài)是無效的!

共享狀態(tài)解釋
future_status::deferred子線程中的任務函仍未啟動
future_status::timeout子線程中的任務正在執(zhí)行中，指定等待時長已用完
future_status::ready子線程中的任務已經(jīng)執(zhí)行完畢，結果已就緒

?實際上，為了方便我們理解，還應該加一個狀態(tài): 無效狀態(tài)(invalid)。這個狀態(tài)存在于:
①future對象沒有接收任何提供者的共享關聯(lián);
②future對象ready完畢后，被調用者通過get()獲取過了。

?

2.2 常用成員函數(shù)
成員函數(shù)功能
valid()判斷共享狀態(tài)是否有效
wait()等待共享狀態(tài)ready
wait_for()等待一段時間
wait_until()等待到某個時間點
get()獲取future的值

注意:

  • 在調用get()時，如果future的共享狀態(tài)不是ready, 則調用者會被阻塞。
  • get()只能被調用一次，第二次會拋出異常。(因為第一次完成后，future的狀態(tài)就是無效的了)
  • 調用wait()方法會阻塞式等待共享狀態(tài)為ready。
  • wait_for()和wait_until()無法保證等待結束后的future對象的狀態(tài)一定是ready! (所以它們不太常用, 因為調用完畢后還需要使用valid()判斷共享狀態(tài))
  • wait_for()和wait_until()的返回值是std::future_status。因此我們可以通過接收它們的返回值來循環(huán)判斷future對象是否ready。

?

3. promise
//包含于頭文件
templatepromise;
templatepromise;  // specialization : T is a reference type (R&)
template<> promise;// specialization : T is void

//構造函數(shù)
promise();								//(1)
promise(promise&& other) noexcept;		//(2) 移動構造
promise(const promise& other) = delete;	//(3) 禁止拷貝構造

//賦值
promise& operator= (promise&& rhs) noexcept; //允許移動賦值
promise& operator= (const promise&) = delete;//禁止拷貝賦值

?promise是一個協(xié)助線程賦值的類，在promise類的內部管理著一個future對象。因此它能夠提供一些將數(shù)據(jù)和future對象綁定起來的接口。

?

3.1 常用成員函數(shù)
成員函數(shù)功能
get_future()獲取future對象
set_value()設置future對象的值(立刻)
set_value_at_thread_exit()在線程結束時，才會設置future對象的值,

?
? get_future()

?get_future()會返回一個future對象, 此時如果去接收它的返回值則會觸發(fā)移動賦值, 將資源轉移。

? set_value()

?設置future對象的值，并立即設置future對象的共享狀態(tài)為ready。

? set_value_at_thread_exit()

?設置future對象的值，但是不會立刻讓future對象的共享狀態(tài)為ready。在子線程退出時，子線程資源被銷毀，再令共享狀態(tài)為ready。

?

3.2 promise的基本使用

①: 子線程set_value—>給主線程

  1. 在主線程中創(chuàng)建promise對象
  2. 將這個promise對象通過引用傳遞的方式傳給子線程的任務函數(shù)(ref)
  3. 子線程在合適的時候調用set_value()方法, 設置future對象的值以及狀態(tài)(ready)
  4. 主線程通過調用promise對象中的get_future()方法獲取到future對象 (這里是移動構造了)
  5. 主線程調用future對象中的get()方法獲取到子線程set_value()所設置的值。
    ?
void func(promise& pr)
{cout<< "Child Thread Working~~~"<< endl;
    cout<< "Child Thread: Waiting 3 seconds!"<< endl;
    this_thread::sleep_for(chrono::seconds(3));
    
    pr.set_value(3);
    this_thread::sleep_for(chrono::seconds(1));
    cout<< "Child Exit"<< endl;
}

int main()
{promisepr;
    thread t(func, ref(pr));
    auto f = pr.get_future();
    this_thread::sleep_for(chrono::seconds(1));
    cout<< "Get Future: "<< f.get()<< endl;
    t.join();
    return 0;
}

注意:

?根據(jù)現(xiàn)象, 我們可以發(fā)現(xiàn)主線程在調用f.get()時阻塞了一會。此時說明子線程還沒有執(zhí)行到set_value(), 此時的future對象中的共享狀態(tài)不是ready, 因此主線程會被阻塞。

②: 主線程set_value–>給子線程

  1. 在主線程中創(chuàng)建promise對象
  2. 將這個promise對象通過引用傳遞的方式傳給子線程的任務函數(shù)(ref)
  3. 主線程在合適的時候調用set_value()方法, 設置future對象的值以及狀態(tài)(ready)
  4. 在編碼子線程時，設置依future對象的值的判斷條件，當future的共享狀態(tài)或者值滿足條件時，執(zhí)行某一任務(或終止)
void func2(promise& pr)
{int i = 0;
    auto val = pr.get_future().get();
    if(val == 1){cout<< "Get Value: "<< val<< endl;
        //do something
    }
    else{cout<< "Get Value: "<< val<< endl;
        //do something
    }
}

int main()
{promisepr;
    thread t(func2, ref(pr));
    cout<< "Main Thread: Waiting 3 seconds!"<< endl;
    this_thread::sleep_for(chrono::seconds(3));
    pr.set_value(1);
    t.join();
}

輸出:

Main Thread: Waiting 3 seconds!
Get Value: 1

?

?

4. package_task
//包含于頭文件
templatepackaged_task;     // undefined
templateclass packaged_task;

//構造函數(shù)
packaged_task() noexcept;						//default (1)
templateexplicit packaged_task (Fn&& fn);				//initialization (2)
packaged_task (const packaged_task&) = delete;	//copy [deleted] (3)
packaged_task (packaged_task&& x) noexcept;		//move (4)

//賦值
packaged_task& operator=(packaged_task&& rhs) noexcept; //move (1)
packaged_task& operator=(const packaged_task&) = delete;//copy [deleted] (2)

?package_task包裝了一個函數(shù)對象(類似于function), 我們可以把它當做函數(shù)對象來使用。package_task可以將內部包裝的函數(shù)和future綁定到一起，以便于進行后續(xù)的異步調用。因此我們可以將其理解為它自帶了一個函數(shù)，并且該函數(shù)和future對象綁定到了一起，我們不需要額外定義函數(shù)方法了，直接實現(xiàn)package_task中的函數(shù)對象即可。

?但package_task相比于promise有個缺點，它里面包裝了函數(shù)，而該函數(shù)的返回值就是future對象的值。它無法像使用promise那樣靈活。

?

4.1 常用成員函數(shù)

?package_task中最常用的就是get_future()方法了。它能夠獲取到package_task中的future對象。

?

4.2 package_task的基本使用

?將package_task作為線程的啟動函數(shù)傳過去，傳參方式必須是引用傳遞 ref()。

int main()
{packaged_taskpt_Add([](int x, int y)
    {cout<< "Running~~~~~~~~~~"<< endl;
        this_thread::sleep_for(chrono::seconds(3));
        return x + y;
    });

    futurefi = pt_Add.get_future();

    cout<< "Start Thread!"<< endl;
    thread t(ref(pt_Add), 10, 20);

    cout<< "before get"<< endl;
    int val = fi.get();
    cout<< "val: "<< val<< endl;
    t.join();
    return 0;
}

輸出:

Start Thread!
before get
Running~~~~~~~~~~
val: 30

?

?

5. async
//構造函數(shù)
// (1)
templatefuture::type>async (Fn&& fn, Args&&... args);

// (2)
templatefuture::type>async (launch policy, Fn&& fn, Args&&... args);	//policy是啟動策略

?async是一個函數(shù)，它相比于前面的promise和package_task要高級一些。async可以直接啟動一個子線程，然后讓這個子線程執(zhí)行對應的任務函數(shù)，任務函數(shù)的返回值就會被存儲到future對象當中，future對象也就是async函數(shù)的返回值。主線程只需要接收asnyc的返回值，然后調用get()方法即可獲取到future對象中保存的值。

注: 更高級并不代表更好用，只是它的集成度更高一些，省去了我們要自己創(chuàng)建線程的步驟。async仍然有package_task的缺點，它無法像promise那樣自由控制future在何時賦值。

?

? launch policy啟動策略

策略解釋
std::launch::async調用async函數(shù)時會創(chuàng)建新的線程，讓該線程執(zhí)行任務函數(shù)
std::launch::deferred調用async函數(shù)時不會創(chuàng)建新的線程，也不會去執(zhí)行該任務函數(shù)。只有調用了async返回的future的get()方法或者wait()方法時才會去執(zhí)行任務。(執(zhí)行該任務的是主線程)

?

5.1 async的基本使用

? 使用默認的啟動策略 — 調用async創(chuàng)建子線程, 并讓該線程去執(zhí)行任務

int main()
{futuref = async([](int x, int y)
   {   cout<< "Child Thread: Waiting 3 seconds!"<< endl;
       this_thread::sleep_for(chrono::seconds(3));
       return x + y;
   }, 10, 20);

   this_thread::sleep_for(chrono::seconds(1));
   cout<< "Get Value: "<< f.get()<< endl;
   return 0;
}

輸出:

Child Thread: Waiting 3 seconds!
Get Value: 30

? 使用deferred啟動策略 — 調用async不創(chuàng)建子線程

int main()
{futuref = async(launch::deferred, [](int x, int y)
    {cout<< "Child Thread "<< this_thread::get_id()<< ": Waiting 3 seconds!"<< endl;
        this_thread::sleep_for(chrono::seconds(3));
        return x + y;
    }, 10, 20);

    cout<< "Main Thread "<< this_thread::get_id()<<": Working!!!"<< endl;
    auto val = f.get();
    cout<< "Get Value: "<< val<< endl;
	return 0;
}

輸出:

Main Thread 1: Working!!!
Child Thread 1: Waiting 3 seconds!
Get Value: 30

?我們可以發(fā)現(xiàn)使用deferred策略時，是不會創(chuàng)建新的線程的。也就是說async的任務函數(shù)依然是由主線程自己去執(zhí)行的，只不過執(zhí)行的時機可以控制 (在調用get()方法時會去執(zhí)行)，這個機制類似于回調函數(shù)，你主動去調用get()才會去回調執(zhí)行async的任務。

?

?

6. promise、package_task、async的對比與總結
  1. promise類的使用相對靈活，但是需要自己創(chuàng)建線程，并且需要自己寫一個函數(shù)對象。
  2. package_task類受限于只能使用函數(shù)返回值作為future對象的值。使用它也需要自己創(chuàng)建線程，但不需要額外寫函數(shù)對象，直接將package_task當做函數(shù)對象去使用即可。
  3. async類集合度較高，它也受限于只能使用函數(shù)返回值作為future對象的值。但是async定義時可以自動創(chuàng)建線程，并讓線程執(zhí)行async中的任務函數(shù)。async的使用最簡單，但是自由度較低。

?

細節(jié)總結:

  1. 調用get_future()方法, 并不會讓線程被阻塞。只要調用future對象的get()方法，才可能被阻塞。(future共享狀態(tài)沒有ready就會被阻塞, 前提是future共享狀態(tài)有效)
  2. 創(chuàng)建線程時，給線程傳參要注意使用ref()的時機。

你是否還在尋找穩(wěn)定的海外服務器提供商？創(chuàng)新互聯(lián)www.cdcxhl.cn海外機房具備T級流量清洗系統(tǒng)配攻擊溯源，準確流量調度確保服務器高可用性，企業(yè)級服務器適合批量采購，新人活動首月15元起，快前往官網(wǎng)查看詳情吧

分享標題：C++11線程異步-創(chuàng)新互聯(lián)
文章來源：http://muchs.cn/article24/djgoje.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供服務器托管、定制開發(fā)、軟件開發(fā)、網(wǎng)站改版、企業(yè)建站、App設計

廣告

聲明：本網(wǎng)站發(fā)布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經(jīng)允許不得轉載，或轉載時需注明來源： 創(chuàng)新互聯(lián)

微信小程序開發(fā)