c++多线程笔记
多線程筆記
本筆記基于b站多線程講解視頻
筆記pdf版鏈接 提取碼：1234
md文檔版鏈接 提取碼：1234
正文如下：
vs快捷鍵：
? 執行快捷鍵：ctrl+F5 。
? 加斷點：F9 => 執行: F5 => 下一步：F10
第一節 并發基本概念及實現、進程、線程基本概念
（1）并發、進程、線程基本概念和綜述
并發
兩個及以上的任務（獨立活動）同時進行（發生）；（一個程序同時執行多個獨立任務）
單核cpu，某時刻只可以執行一個任務，由操作系統調度，每秒進行多次“任務切換”，形成多任務同時進行（并發）的錯覺。（又稱為上下文切換，需要保存任務的上下文，有時間開銷）
多核cpu，能夠實現真正的并發（目的是為了提高性能）。
可執行程序
磁盤上的一個文件（Windows：.exe文件；linux（x執行權限））
進程
執行可執行程序的方法（windows：雙擊；linux：./文件名）
進程：可執行程序執行起來了，就是創建了一個進程。（就是運行起來的可執行程序）
線程
用來執行代碼的。（代碼的執行道路，一個進程可以有多個線程）
a）每個進程（運行起來的可執行程序），有且僅有一個主線程（0號線程）。
b) 當運行程序后，產生進程，與此同時，主線程也啟動了。
c）執行程序，實際上是主線程來執行（調用)這個main函數中的代碼。
d）每個線程都需要一個單獨的堆棧空間。（線程并不是越多越好，線程間切換需要時間）
多線程程序可以同時干很多事兒，效率高。
2）并發的實現方法
并發：兩個及以上的任務（獨立活動）同時進行（發生）
實現并發的手段：
? a）多個進程實現并發。
? b）單獨進程中，創建多個線程實現并發。（寫代碼實現）
多進程并發
wps啟動后一個進程，ie瀏覽器一個進程，多個進程并發。
進程（內存塊是私有的）之間的通信：（同一個電腦上通過：管道、文件、消息隊列、共享內存）（不同電腦之間通過socket通信技術）實現；
多線程并發
單個進程中，創建多個線程（輕量級進程），可以共享相同的內存空間。
共享內存帶來的問題：數據一致性問題。
（3）c++新標準線程庫
c++11新標準開始，代碼可移植。
第二節 線程啟動、結束，創建線程多法、join，detach
（1）范例演示線程運行的開始和結束
thread（創建）
[ thread {子線程名}（線程調用函數名，參數1，參數……); ]
標準庫類,創建線程，線程入口是xxx函數
join（阻塞主線程）
[ {子線程名}.join( ); ]
join是要阻塞主線程等子線程結束的，也就是說子線程結束前主線程什么事情也不能干
void myprint() {cout << "線程開始執行" << endl;cout << "線程執行結束" << endl; }int main()//主線程 {//可調用對象：myprint（創建線程，線程入口是myprint函數）thread mytobj(myprint);//子線程，一條線被阻塞，另一條線也不會被阻塞，獨立的//加入或匯合，說白了就是阻塞，（阻塞主線程），讓主線程等待子線程執行完畢，然后子線程和主線程匯合mytobj.join();//主線程阻塞，等待myprint執行完畢cout << "I love China!" << endl;return 0; }detach(不阻塞主線程)
[ {子線程名}.detach( ); ]
主線程不與子線程匯合，彼此獨立，你干你的，我干我的，主線程也可提前執行完畢，主線程結束后，子線程剩余部分在系統后臺運行，執行完成后，c++運行時庫負責清理相關資源。（守護線程）
mytobj.detach();joinable（判斷）
[ {子線程名}.joinable( ); ]
返回值：True / Flase
判斷是否可以成功使用join()或者detach()的；
if(mytobj.joinable()) {cout << "可用join()" << endl;mytobj.join(); } else {cout << "不可用join()" << endl; }（2）其他創建線程的手法
用類作為可調用對象
a）void operator()(){}
? 重載()可以使對象像函數那樣使用，常常被稱為函數對象。(這里用作線程對象的構造)
b）thread mytobj(ta);
? 生成線程并且調用拷貝構造函數，復制ta對象，使得在主線程結束后，也可執行子線程內容。
c）mytobj.join();
? 執行ta內容，執行完后，析構復制的ta對象
class TA { public:int m_i;TA(int i):m_i(i) {}TA(const TA &ta):m_i(ta.i) {}//這里重載()可以使對象像函數那樣使用，常常被稱為函數對象。(這里用作線程對象的構造)//必須將對象轉化為函數對象void operator()(){cout<< "1m_i的值為： " << m_i <<endl;cout<< "2m_i的值為： " << m_i <<endl;} };int main() {int myi = 6;TA ta(myi);//創建對象并調用構造函數thread mytobj(ta);//生成線程并且調用拷貝構造函數//mytobj.join();//執行ta，執行完成后析構拷貝的ta對象//若主線程已經執行完畢，myi（傳入引用的話）內存被回收，子線程輸出的m_i結果將不可預料//若主線程執行結束，主線程ta對象被銷毀，但是對象實際已經被{[復制]入子線程}的ta對象依舊存在mytobj.detach();cout << "I love China!" << endl;return 0; }用lambda表達式
auto <lambda表達式名> = [<捕獲函數的局部變量>]（<參數列表>）{ } ；
auto f = []{cout << "線程開始執行" << endl;cout << "線程執行結束" << endl; }; thread mytobj(f); mytobj.join();第三節 線程傳參詳解，detach()大坑，成員函數做線程函數
（1）傳遞臨時對象作為線程參數第一講
需要避免的陷阱①
a) char* p；cout << p << endl;
? *p輸出p指向地址的字母，而p輸出整個字符串。
? 相當于c語言中（printf語句打印%s的時候,提供字符串首地址，打印整個字符串）
b）陷阱一：detach，thread傳值用[ 引用 ]
? （引用）myi實際上是值傳遞，用detach也是安全的。
c）陷阱二：detach，thread傳值用[ 指針 ]
? 不安全，不可用！因為指針指向地址相同，會被銷毀。
d）改進：char myp[]； thread mythread(myprint, myp); void myprint(string& p){}
? 使用const string&代替char*。
void myprint(const int i, const string &p) {cout << i << endl;cout << p.c_str() << endl;return; }int main() {int myi = 1;int& myii = myi;char myp[] = "I love China!";thread mythread(myprint, myi, myp);// ② 陷阱一mythread.join();return 0; }需要避免的陷阱②
a) 陷阱一：（detach）事實上存在，主線程執行完了，系統才將myp轉string。[ 驗證方法見附錄1 ]
b) 改進：（detach）使用臨時對象在thread出進行轉換。
//改進方法： thread mythread(myprint, myi, string(myp));[ thread {子線程名}（線程調用函數名，{數據類型}（參數1），參數……); ]
總結
a）使用int等簡單類型參數，建議使用值傳遞，避免節外生枝。
b) 如果傳遞類對象，避免隱式類型轉換。全部都在thread構建臨時對象！在函數參數出用引用接收，避免在進行一次臨時對象的構造，浪費！
###（2）傳遞臨時對象作為線程參數第二講
線程id概念
[ std::this_thread::get_id() ]
不同線程具有不同id。
臨時對象構造時機抓捕
（3）傳遞類對象、智能指針作為線程參數
類對象
mutable：在const的函數里面修改與類狀態無關的數據成員，用mutable來修飾。
std::ref 函數：目的：創建一個能夠主、子線程能同步修改的數據(即引用)。且不再需要const和mutable。
class TA { public:int m_i;TA(int i):m_i(i) {}TA(const TA &ta):m_i(ta.i) {} };void myprint(A &a)// 用引用就必須帶const {a.m_i = 199; // 線程中修改數據，主線程中不會修改，因為是a對象是拷貝過來的cout << "a.m_i" << a.m_i;return; }int main() {int myi = 6;TA ta(myi);thread mytobj(myprint,std::ref(ta));// ta就是主線程中的ta，未調用拷貝構造函數。mytobj.join();cout << "myi" << myi;return 0; }智能指針
[ 智能指針相關解釋見附錄2 ]
unique_str不能拷貝問題：
std::move：[ thread mytobj( myprint, std::move(myp) ); ]
將myp置為空，將指針所有權交給q。
void myprint(unique_str<int> q){/*……*/} //將myp置為空，將指針所有權交給q。int main() {unique_str<int> myp(new int(100));thread mytobj(myprint,std::move(myp));// unique_str不支持拷貝，但子線程傳值需要拷貝mytobj.join();cout << "myi" << myi;return 0; }（4）用成員函數指針做線程函數
a）[ thread {子線程名}（&類名::成員函數，類對象，參數 ); ]
b）&ta==std::ref(ta)
? &指取this指針。
class TA { public:int m_i;TA(int i):m_i(i) {}TA(const TA &ta):m_i(ta.i) {}void thread_work(int num){/*……*/}void operator()(){/*……*/} };int main() {TA ta(10);thread mytobj(&ta::thread_work,std::ref(ta),100);//&ta==std::ref(ta),傳入引用，不拷貝//thread mytobj(ta,100);// 以operator()函數為入口mytobj.join();cout << "myi" << myi;return 0; }第四節 創建多個線程、數據共享問題分析、案例代碼
（1）創建和等待多個線程
線程入口函數（某線程執行的函數）
a）多個線程混亂執行，與線程調度機制有關。
b）將thread放入容器，一次創建多個線程。
void myprint(int q) {cout << "id" << std::this_thread::get_id() << endl;return; }int main() {vector<thread> mythreads;for(int i = 1;i < 10; i++){mythreads.push_back(thread(myprint,i));}for(auto iter = mythreads.begin(); iter != mythreads.end(); ++iter){iter->join();}return 0; }（2）數據共享問題分析
只讀的數據
安全穩定，不需特殊處理手段。
vector<int> g_v = {1};//只讀的共享數據void myprint() {cout << "id:" << std::this_thread::get_id() << "的線程g_v值：" << g_v[0] << endl; }int main() {thread mytobj(myprint);mytobj.join();cout << "I love China!" << endl;return 0; }有讀有寫
// 2個線程寫，8個線程讀 // 要求讀的時候不能寫，寫的時候不能讀。 // 2個線程不能同時寫，8個線程不能同時讀。其他案例
// 數據共享：十個窗口，兩個窗口同時都要訂99座。（3）共享數據的保護案例代碼
又讀又寫，程序出異常。
因此引入下一節互斥量的概念。
//網絡游戲服務器 //兩個自己創建的線程： // 一個線程：收集玩家命令，并把命令數據寫到一個隊列中。 // 另一個線程：從隊列中取出玩家發送的命令，解析，然后執行玩家需要的動作。 // (list: 頻繁按順序插入和刪除數據時效率高 vector：隨機插入和刪除數據效率高)class TA { public://收集玩家命令線程//寫數據void inMsgRecvQueue(){for(int i = 0; i < 10000; ++i){cout << i <<" "<< std::this_thread::get_id() << endl;msgRecvQueue.push_back(i);//假設i為玩家命令}}//取出玩家發送的命令線程//讀數據，刪除數據void outMsgRecvQueue(){for(int i = 0; i < 10000; ++i){if(!msgRecvQueue.empty()){cout << "消息隊列不為空" << endl;int command = msgRecvQueue.front(); // 返回第一個元素。msgRecvQueue.pop_front();//處理完之后移除}else{cout << "消息隊列為空" << endl;}}} private:std::list<int> msgRecvQueue;//收集玩家命令，并把命令數據寫到一個隊列中 };int main() {TA myobja;std::thread myOutMsgObj(&A::outMsgRecvQueue,&myobja);//使用引用，返回this指針，保證主線程和子線程使用的是同一個對象std::thread myInMsgObj(&A::inMsgRecvQueue,&myobja);myOutMsgObj.join();myInMsgObj.join();return 0; }第五節 互斥量概念、用法、死鎖演示及解決詳解
（1）互斥量（mutex）的基本概念
互斥量：是一個類對象，理解成一把鎖。只有一個線程可以鎖住數據并使用。
聲明了一個mutex變量a后，可以用a.lock(),a.unlock()進行加鎖解鎖，加鎖和解鎖的次數必須相等。
加鎖期間能保證當前線程的操作不會被打斷。
（2）互斥量的用法
頭文件包含：#include
mutex my_mutex;// 聲名變量my_mutexlock()unlock()
a）先lock()，再操作共享數據，unlock()；
b）lock()，unlock()成對出現。
優點：靈活 缺點： lock()，unlock()不成對
std::lock_guard類模板
一個用類實現的，包裝好了的鎖聲明一個mutex變量a后，可以初始化一個類模板
例：lock_guard obj(a);
obj對象在被初始化的時候自動加鎖，能在離開當前作用域后，自動析構解鎖。
缺點：不靈活 。
a）可以使用 { } 改變他的作用域周期，例如：
{ cout<< ……………… 略{lock_guard<std::mutex> sbGuard(my_mutex);msgRecvQueue.push_back(i);} } return;b）相當于：
{ /* ……………… */ {my_mutex.lock();msgRecvQueue.push_back(i);my_mutex.unlock();} /* ……………… */ } return;（3）死鎖
有兩個線程（A和B）和兩個鎖（c和d），A鎖了c，還想要d的鎖進行下一步操作，但這時B鎖了d，但是想要c進行下一步操作。于是彼此互相鎖死。
eg：張三在北京等深圳李四，李四在深圳等北京張三，互相等，彼此鎖死。
死鎖的演示
死鎖的一般解決方案
1、保證兩個互斥鎖的上鎖順序一致
2、或用lock()這個函數模板，進行同時上鎖。（只有當每個鎖都是可鎖的狀態，才會真正一次性兩個互斥量同時上鎖，程序才會繼續向下走）
要么兩個都鎖，要么兩個都不鎖。
mutex mutex2; mutex mutex1;/* 1、保證兩個互斥鎖的上鎖順序一致 */mutex1.lock();mutex2.lock();//其他代碼塊使用mutex1、mutex2也需要先1后2，避免死鎖 /* ………… */mutex1.unlock();mutex2.unlock(); /* 2、或用lock()這個函數模板，進行同時上鎖 */std::lock()函數模板
目的：使用兩個以上的鎖，并且避免因為鎖的執行順序導致的死鎖問題。
要么都鎖，要么都不鎖。
用lock()這個函數模板，進行同時上鎖。（只有當每個鎖都是可鎖的狀態，才會真正一次性兩個互斥量同時上鎖，程序才會繼續向下走）
lock(a, b); /* ... */ a.unlock(); b.unlock();但此時仍需要考慮unlock()問題，因此引入std::lock_guard的std::adopt_lock參數。
std::lock_guard的std::adopt_lock參數
std::adopt_lock：（結構體對象）表示互斥量已被lock，無需再次加鎖，只需要負責解鎖即可。
lock(a, b); lock_guard<mutex> obj1(a,adopt_lock); lock_guard<mutex> obj2(b, adopt_lock); /* ... */第六節 unique_lock詳解
（1）unique_lock取代lock_guard
一個用類實現的，包裝好的鎖，但相比lock_guard 功能更多更靈活，沒有額外參數的情況下，效果和lock_guard相同。（unique_lock obj(a);）
第一個參數：mutex對象。
（2）unique_lock第二個參數
std::adopt_lock
std::adopt_lock：（結構體對象）表示互斥量已被lock，無需再次加鎖，只需要負責解鎖即可。{例子見上節std::lock_guard的std::adopt_lock參數}
std::try_to_lock
嘗試去鎖，如果沒鎖成功也會返回，不會卡死在那，可用owns_lock()得到是否上鎖的信息。
unique_lock<mutex> obj(mute,try_to_lock); if (obj.owns_lock()) {/*如果鎖上了要怎么做…*/} else {/*沒鎖上也可以干別的事*/}std::defer_lock
初始化：用一個還沒上鎖的mutex變量初始化一個對象。
加鎖：自己可以在后續代碼段中的某個位置加鎖。
解鎖：離開作用域時，能幫助我們解鎖，當然我們也能提前手動a.unlock()解鎖。
mutex a; unique_lock<mutex> obj(a,defer_lock); /* 一些代碼 */ a.lock(); //也可結合條件判斷語句使用a.try_lock() ，若成功鎖上能返回true，否則返回false（3）unique_lock的成員函數
lock()
unlock()
{mutex a;unique_lock<mutex> obj(a,defer_lock);/* 一些代碼 */a.lock(); //也可結合條件判斷語句使用a.try_lock() ，若成功鎖上能返回true，否則返回false /*處理共享代碼*//*因為有一些非共享代碼要處理，手動解鎖*/obj.unlock();/*處理非共享代碼*/obj.lock();/*處理共享代碼*///obj.unlock();/* 可以不寫，因為defer_lock離開作用域時會幫助我們解鎖 */ }release()
返回他所管理的mutex對象指針，并釋放所有權。
std::unique_lock<std::mutex> obj(my_mutex); std::mutex *ptx = obj.release(); //解鎖和上鎖責任轉移給ptx/*處理非共享代碼*/ptx->unlock();try_lock()
defer_lock參數與try_lock()搭配例子：
unique_lock<mutex> obj(mute,defer_lock); if (obj.try_lock() == true) {/*如果鎖上了要怎么做…*/} else {/*沒鎖上也可以干別的事*/}owns_lock()
用owns_lock()得到try_to_lock是否上鎖的信息。
try_to_lock參數 和 owns_lock()成員函數配對使用。
unique_lock<mutex> obj(mute,try_to_lock); if (obj.owns_lock()) {/*如果鎖上了要怎么做…*/} else {/*沒鎖上也可以干別的事*/}一般來講，鎖住的代碼越少，效率越高
（4）unique_lock所有權傳遞
unique_lock對mutex對象的所有權可轉移，但不能復制。
unique_lock所有權傳遞方法一：
move( )
unique_str所有權傳遞：
p1.reset(p2.release()); 意為將p2指針所有權給p1，并將p2置為空。
unique_lock所有權傳遞：
unique_lock<std::mutex > obj1( move(obj2) );意為將obj2指針所有權給obj1，并將obj2置為空。
std::unique_lock<std::mutex> obj2(a,defer_lock);std::unique_lock<std::mutex> obj1(std::move(obj2));//移動語義unique_lock所有權傳遞方法二：
return unique_lock<std::mutex >
[ 涉及有關移動構造函數問題，見附錄3 ]
unique_lock<mutex> temp() {mutex my_mutex;unique_lock<mutex> temp(my_mutex);return temp;//返回對象temp會讓系統生成臨時unique_lock對象，并調用unique_lock的移動構造函數 }unique_lock<mutex> obj = temp();（5）總結
lock_guard 配合 adopt_lock使用
unique_lock配合 defer_lock使用
在兩種情況都能使用時，推薦使用lock_guard，因為它更快并且使用的內存空間更少。
unique_lock支持所有權的傳遞，所以更加靈活。
第七節 單例設計模式共享數據分析、解決，call_once
(1) 設計模式大概談
設計模式是一套被反復使用的、多數人知曉的、經過分類編目的、代碼設計經驗的總結。
使用設計模式是為了重用代碼、讓代碼更容易被他人理解、保證代碼可靠性。
(2) 單例設計模式
-
1、單例類只能有一個實例。
-
2、單例類必須自己創建自己的唯一實例。
-
3、單例類必須給所有其他對象提供這一實例。
-
意圖：保證一個類僅有一個實例，并提供一個訪問它的全局訪問點。
-
關鍵代碼：構造函數是私有的。（私有構造函數只能在函數內部調用，外部不能實例化，所以私有構造函數可以防止該類在外部被實例化）
-
為什么不能再單例類析構函數中進行delete：
? 因為你是需要delete調用析構函數，而不是調用析構函數才delete。
(3) 單例設計模式共享數據問題分析、解決
加鎖問題：
if (m_instance == NULL)，不代表m_instance一定沒被new過；因為多個線程上下文切換問題，可能線程1要執行 m_instance == new MyCAS();行，但還沒執行完，切換線程二，此時m_instance仍然等于NULL，線程2會new一次，切換回線程1仍然會new一次，因此為了不影響單例，需要加鎖。
{std::unique_lock<std::mutex> mymutex(resource_mutex); //自動加鎖，但效率非常低if (m_instance == NULL){m_instance == new MyCAS();static CGarhuishou cl;} }但每次執行該函數，都會導致串行，效率非常低，因此我們利用if (m_instance == NULL)，不代表m_instance一定沒被new過，再加一個判斷，則在提高效率同時，又保證單例。
static MyCAS *GetInstance() {//提高效率 if (m_instance == NULL)//a)如果if (m_instance != NULL) 條件成立，則肯定表示m_instance已經被new過了；//b)如果if (m_instance == NULL)，不代表m_instance一定沒被new過；因為多個線程上下文切換問題，可能if (m_instance == NULL) //雙重鎖定（雙程檢查）{ std::unique_lock<std::mutex> mymutex(resource_mutex); //自動加鎖，但效率非常低if (m_instance == NULL){m_instance == new MyCAS();static CGarhuishou cl;}}return m_instance; }(4) std::call_once
第二個參數是一個函數名func()；
std::call_once()功能是能夠保證函數func()只被調用一次。
具備互斥量這種能力，而且效率上比互斥量消耗的資源更小；
需要與標記std::once_flag一起使用：
? 通過這個標記決定對應函數a()是否執行，調用call_once()成功后，std::call_once()就把這個標記設置為一 種已調用狀態，后續繼續調用std::call_once()，只要once_flag被設置為了“已調用”狀態，那么對應的函數a() 就不會再被執行了。
std::once_flag g_flag; // 標記 /* 函數func() */ //兩個線程同時執行到這里，其中一個線程要等另外一個線程執行完畢CreateInstance(),這里可以把g_flag看作一把鎖 std::call_once(g_flag,func()); // sleep 20s std::chrono::microseconds dura(20000);//std::chrono::duration 表示一段時間 std::this_thread::sleep_for(dura);第八節 條件變量condition_variable
（1）條件變量std:: condition_variable、wait()、notify_one()
condition_variable是一個類，與條件相關，需要等待一個條件的達成，和互斥量來配合工作的
具有成員函數：wait()、notify_one()等等。
線程A：等待一個條件滿足
線程B：專門在消息隊列中扔消息，線程B觸發了這個條件（notify_one()等），A就滿足條件了（可以解鎖wait()），繼續執行
std::condition_variable my_cond; // 條件變量對象wait()
第一個參數是：互斥量。
第二個參數是：lambda表達式。
? 如果lambda表達式返回值是false，那么wait將解鎖第一個參數（互斥量)(讓出CPU)，并堵塞到本行。
? 堵塞到什么時候呢？堵塞到其他某個線程調用notify_one()成員函數為止。
? 如果返回true，那么wait()直接返回。
? 如果沒有第二個參數，就跟默認第二個參數返回false效果一樣。
notify_one()
嘗試把wait的線程喚醒，執行完這行，wait就被喚醒了
如果要喚醒所有wait的線程，使用notify_ all()。
my_cond.notify_one(); // my_cond.notify_ all();假如現在A線程正在處理一個事物 ，需要一段時間，并沒有卡在wait等你喚醒
而B線程已經調用過notify_one了，那notify_one就沒效果了。
A線程notify_one之后，可能會接著lock，而另一個線程可能也在lock，兩個線程誰先拿到鎖不一定，所以死鎖的問題就出現了。
（2）代碼深思考
解釋在代碼注釋里。
class A { public:void inMsgRecvQueue(){for (int i = 0; i < 10000; i++){cout << "inMsgRecvQueue()執行，插入一個元素" << i << endl;std::unique_lock<std::mutex> sbguard(my_mutex);msgRecvQueue.push_back(i);//假如outMsgRecvQueue（）正在處理一個事務，需要一段時間，而不是正卡在wait()那里等待你的喚醒，//那么此時這個notify_one（）這個調用也許就沒效果；my_cond.notify_one();//我們嘗試把wait()線程喚醒,執行完這行，那么outMsgRecvQueue()里面的wait()就會被喚醒//喚醒之后的事情后續研究；}}void outMsgRecvQueue(){int command = 0;while (true){std::unique_lock<std::mutex> sbguard(my_mutex);//但其他線程用notify_one()將本wait(原來是睡著/堵塞)的狀態喚醒后，wait()就開始恢復干活了，那恢復后的//wait()干什么活？//a)wait()不斷的嘗試重新獲取互斥量鎖，如果獲取不到，那么流程就卡在wait()這里等著獲取，如果獲取到了互斥鎖，//那么wait()就繼續執行b//b)上鎖（實際上獲取鎖了就等于上了鎖）//b.1)如果wait有第二個參數（lamdba）,就判斷這個lamdba表達式，如果表達式為false,//那么wait()又對互斥量解鎖然后又休眠，這里繼續等待再次被notify_one()喚醒//b.2)如果lamdba表達式為true,則wait()返回，流程走下來（此時互斥鎖被鎖著）//b.3)如果wait()沒有第二個參數,則wait()返回，流程走下來//為防止虛假喚醒：wait()中要有第二個參數（lambda）并且這個lambda中要正確處理公共數據是否存在my_cond.wait(sbguard, [this] { //一個lambda就是一個可調用對象（函數）if (!msgRecvQueue.empty())return true;return false;});//流程能走到 這里來，這個互斥鎖一定是鎖著的。同時msgRecvQueue至少有一條數據的command = msgRecvQueue.front();msgRecvQueue.pop_front(); sbguard.unlock(); //因為unique_lock的靈活性，所以我們可以隨時解鎖，以免鎖住太長時間cout << "outMsgRecvQueue()執行，取出一個元素" << command << endl;}//end while}private:std::list<int> msgRecvQueue;//容器（消息隊列），代表玩家發送過來的命令。std::mutex my_mutex;//創建一個互斥量（一把鎖）std::condition_variable my_cond;//生成一個條件變量對象 };（3）notify_all()
notify_one()只能通知一個線程；
notify_ all()通知所有線程;
第九節 async、future、packaged_task、promise
（1）std::async std::future創建后臺任務并返回值
目的：希望線程返回一個結果
async：（函數模板）
頭文件：#include< future >
目的：啟動一個異步任務（自動創建一個線程并開始執行對應的線程入口函數）
返回值：std::future對象（調用std::future對象的成員函數get()來獲取結果）
參數：
? 第一個參數是std::launch::的枚舉類型，包含std::launch::deferred、std::launch::async。后面的參數同lock參數（若是類的成員函數做對象，第二個參數是類的成員函數，第三個參數是類對象，第四個參數及以后是成員函數的參數等等……）
? 參數 std::launch::deferred：
? a）表示線程入口函數調用被延遲到std::future的wait()或者get()函數調用時才執行；
? b）延遲調用：沒有創建線程，是在主線程中調用的線程入口函數 ；
? c）如果wait()或者get()沒有沒調用，就不會執行。
參數 std::launch::async：? a）若std::async()沒有第一個參數，默認使用（std::launch::async | std::launch::deferred）
? b）在調用async函數的時候就開始創建線程
std::future<int> result = std::async(std::launch::async, &A::mythread2, &a, tmppar);std::future:（類模板）需要兩步，一綁定，二返回值。
成員函數：
? get()：不拿到返回值，就堵塞線程。//本函數只能調用一次。
? wait()：等待線程返回，本身并不返回結果。
share_future：（類模板）
? share_future的get()函數復制數據。
? future的get()函數轉移數據。
class A { public:int mythread2(int mypar) //線程入口函數{cout << mypar << endl;return mypar;} };int main() {A a;int tmppar = 12;//std::future<int> result = std::async(mythread);//創建一個線程并開始執行,綁定關系,流程并不卡在這里std::future<int> result = std::async(std::launch::async, &A::mythread2, &a, tmppar);cout << result.get()<< endl;//卡在這里等待mythread()執行完畢，拿到結果；只能調用一次；//result.wait();//等待線程返回，本身并不返回結果return 0; }（2）std::packaged_task模板類
把對象（函數、lamdba表達式等等）包裝起來，方便將來作為線程入口函數來調用。
[ packaged_task<函數返回值類型(函數參數類型)> packaged_task變量名(線程入口函數名); ]
成員函數：
? get_future()：返回std::future值，調用future的get()函數得到返回值。
//線程入口函數mythread std::packaged_task<int(int)> mypt(mythread);//我們把函數mythread通過packaged_task包裝起來 std::thread t1(std::ref(mypt),1); //線程直接開始執行,第二個參數作為線程入口函數的參數 t1.join(); std::future<int> result = mypt.get_future();//std::future對象里包含有線程入口函數的返回結果，這里result保存mythread返回的結果 cout <<result.get() << endl;lamdba表達式：將函數寫成lamdba表達式做參數。
vector < std::packaged_task<int(int)>> mytasks;//容器int main() {cout << "main" << "threadid= " << std::this_thread::get_id() << endl;std::packaged_task<int(int)> mypt([](int mypar) {cout << mypar << endl;std::chrono::milliseconds dura(5000); //定一個5秒的時間std::this_thread::sleep_for(dura); //休息一定時常 return 5;});//將函數寫成lamdba表達式做參數。mytasks.push_back(std::move(mypt)); //容器，這里用了移動語義std::move//將權限給mytasks，并釋放自己的權限std::packaged_task<int(int)> mypt2;auto iter = mytasks.begin();mypt2 = std::move(*iter); //移動語義mytasks.erase(iter); //刪除一個元素，迭代器已經失效了，所以后續代碼不可以再使用iter;mypt2(105);//直接調用，相當于函數調用，調用lamdbastd::future<int> result = mypt2.get_future();cout << result.get() << endl;return 0; }（3）std::promise類模板
std::promise 與 std::future綁定 通過std::promise對象的get_future()
在某個線程中給它賦值，然后我們可以在其他線程中把這個值取出來用。
通過promise保存一個值，在將來我們通過把一個future綁定到這個promise上來得到這個綁定的值。
函數成員：set_value()，將需要傳回future的值放入其中。
void mythread(std::promise<int>&tmpp, int calc) {/*…………………………*/calc++;/*…………………………*/int result = calc; //保存結果tmpp.set_value(result); //結果保存到了tmpp這個對象中 } void mythread2(std::future<int> &tmpf) {auto result = tmpf.get();//不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();//promise與future綁定，用于獲取線程返回值std::thread t2(mythread2,std::ref(fu1));t2.join(); //等mythread2執行完畢return 0; }第十節 future其他成員函數、shared_future、atomic
（1）std::future其他成員函數
valid()：返回get()返回的std::future對象是否有意義。
wait_for：等待函數。
枚舉類型：std::future_status::timeout（超時）、ready、deferred（遞 延）
std::future<int> result = std::async(mythread); std::future_status status = result.wait_for(std::chrono::seconds(1));// 時間表達式 //std::chrono::milliseconds dura(5000); //std::this_thread::sleep_for(dura); if(status == std::future_status::timeout){ //超時：我想等待1s，希望你返回數值給我，但是你沒有返回，所以超時//表示線程mythread還沒執行完，cout << "超時，線程還沒執行完" << endl; } else if(status == std::future_status::ready){cout << " 線程成功返回 " << endl; } else if(status == std::future_status::deferred){cout << "線程被延遲執行" << endl;// 這個線程函數是在主線程執行的，相當于沒有創建子線程cout << result.get() << endl; }（2）std::shared_future類模板
解決多個線程都想得到結果。
share_future的get()函數復制數據。
future的get()函數轉移數據。
std::packaged_task<int(int)> mypt(s7::myThread2); std::thread t1(std::ref(mypt),1); t1.join(); //std::future<int> result = mypt.get_future(); //std::shared_future<int> result_s(std::move(result));//result_s(result.share());//移動語義 //bool ifcanget = result.valid();//返回值是否為空// 等價于 // //通過get_future 構造一個shared_future 對象 std::shared_future<int> result_s(mypt.get_future());（3）原子操作std::atomic
原子操作概念引出范例
互斥量：多線程編程中，保護共享數據：先鎖，操作共享數據，開鎖
有兩個線程對一個變量進行操作atomVal共享變量，一個線程讀、一個線程寫，即使這樣也會出問題
原子操作不需要用到互斥量加鎖（是無鎖）技術的多線程并發編程方式
在多線程中，不會被打斷的程序執行片段，效率比互斥量高，原子操作是不可分割的狀態
互斥量往往是針對一個代碼段，而原子操作一般對某個變量操
std::atomic
類模板為了封裝某個類型的值
// 讀線程atomVal表示多個線程之間共享的變量；
int temVal = atomVal;
//寫線程
atomVal = 6;
//myMetux.lock(); //count++; //myMetux.unlock();//如果不加鎖，由于匯編代碼可能是多句，上下文切換，會導致結果不穩定// 等價于 //std::atomic<int> my_conut = 0;my_conut++;//原子操作不會被打斷一般用于計數或者統計或者做標識（bool）
第十一節 std::atomic續談、std::async深入談
（1）原子操作std::atomic續談
atomic 針對 ++、–，+=，&=、|=、^=等運算符是可以的，有些操作不是原子操作。
std::atomic<int> my_test = 0; my_test += 1;//結果正確 my_test = my_test + 1;//結果正確load()：以原子方式讀atomic對象的值
store():以原子方式寫入內容
atomic<int> atm; atm = 0; cout << atm << endl; //讀原atm是原子操作子，但是整個這一行代碼并不是原子操作 auto atm2(atm.load());//以原子方式讀atomic對象的值 atm.store(12);//以原子方式寫入內容（2）std::async深入談
std::async參數詳解
如果沒有參數默認使用（std::launch::async | std::launch::deferred）
使用場景，若線程緊張，就使用deferred，不創建線程繼續執行，防止程序崩潰。
std:: async與std::thread的區別
std::async()與std::thread()最明顯的不同，就是async并不一定創建新的線程
std::thread() 如果系統資源緊張，那么可能創建線程失敗，整個程序可能崩潰。
std::thread()創建線程的方式，如果線程返回值，你想拿到這個值也不容易；
std::async()創建異步任務，可能創建也可能不創建線程；并且async調用方式很容易拿到線程入口函數的返回值。
由于系統資源限制：
（1）如果使用std::thread()創建的線程太多，則可能創建線程失敗，系統報告異常，崩潰；
（2）如果用std::async,一般就不會報異常崩潰，因為如果系統資源緊張導致無法創建新線程的時候，std::async這種不加額外參數的調用就不會創建新線程，而是后續誰調用了future::get()來請求結果，那么這個異步任務就運行在執行這條get()語句所在的線程上。
（3）如果你強制std::async創建新線程，那么就必須使用std::launch::async，承受的代價就是系統資源緊張時，可能程序崩潰。經驗：一個程序里，線程的數量不易超過100-200，與時間片有關，詳情參考操作系統。
std:: async不確定性問題的解決
如果沒有參數默認使用（std::launch::async | std::launch::deferred），則由系統資源是否緊張決定，創不創建線程，這個會導致一些不確定性問題。
int mythread() //線程入口函數 {cout << "mythread start" << "threadid= " << std::this_thread::get_id() << endl; //打印線程idstd::chrono::milliseconds dura(5000); //定一個5秒的時間std::this_thread::sleep_for(dura); //休息一定時常cout << "mythread end" << "threadid= " << std::this_thread::get_id() << endl; //打印線程idreturn 5; } int main() {cout << "main" << "threadid= " << std::this_thread::get_id() << endl;std::future<int> result = std::async(mythread);//流程并不卡在這里cout << "continue....." << endl;//枚舉類型std::future_status status = result.wait_for(std::chrono::seconds(1));//等待一秒if (status == std::future_status::deferred){//線程被延遲執行了，系統資源緊張cout << result.get() << endl; //此時采取調用mythread()}else if (status == std::future_status::timeout)//{//超時：表示線程還沒執行完；我想等待你1秒，希望你返回，你沒有返回，那么 status = timeout//線程還沒執行完cout << "超時：表示線程還沒執行完!" << endl;}else if (status == std::future_status::ready){//表示線程成功返回cout << "線程成功執行完畢，返回!" << endl;cout << result.get() << endl;}return 0; }第十二節 Windows臨界區、各種mutex互斥量
（1）Windows臨界區
Windows臨界區與互斥量用法非常相似；但也有些差別
在“同一個線程”(不同線程中會卡住等待)中， Windows中的“相同臨界區變量”代表的臨界區的進入(EnterCriticalSection)可以被多次調用，但是調用了幾次EnterCriticalSection(),就得調用幾次EnterCriticalSection()
而在C++11中，std::mutex不允許同一個線程中lock同一個互斥量多次，否則報異常；
多線程 互斥量與Windows臨界區對比代碼如下：
#define _WINDOWSJQ_class A { public://把收到的消息入到一個隊列的線程void inMsgRecvQueue(){for (int i = 0; i < 10000; i++){cout << "inMsgRecvQueue()執行，插入一個元素" << i << endl;#ifdef _WINDOWSJQ_EnterCriticalSection(&my_winsec); //進入臨界區（加鎖）msgRecvQueue.push_back(i);LeaveCriticalSection(&my_winsec); //離開臨界區（解鎖）#elsestd::lock_guard<std::mutex> sbguard(my_mutex);msgRecvQueue.push_back(i); //假設這個數字i就是收到的命令，直接弄到消息隊列里邊來； #endif}}bool outMsgLULProc(int &command){ #ifdef _WINDOWSJQ_EnterCriticalSection(&my_winsec);if (!msgRecvQueue.empty()){//消息不為空int command = msgRecvQueue.front();//返回第一個元素，但不檢查元素是否存在msgRecvQueue.pop_front();//移除第一個元素。但不返回；LeaveCriticalSection(&my_winsec);return true;}LeaveCriticalSection(&my_winsec); #elsemy_mutex.lock(); if (!msgRecvQueue.empty()){//消息不為空int command = msgRecvQueue.front();//返回第一個元素，但不檢查元素是否存在msgRecvQueue.pop_front();//移除第一個元素。但不返回；my_mutex.unlock(); //所有分支都必須有unlock()return true;}my_mutex.unlock(); #endifreturn false;}//把數據從消息隊列取出的線程void outMsgRecvQueue(){int command = 0;for (int i = 0; i < 10000; i++){bool result = outMsgLULProc(command);if (result == true){cout << "outMsgRecvQueue()執行，取出一個元素" << endl;//處理數據}else{//消息隊列為空cout << "inMsgRecvQueue()執行，但目前消息隊列中為空！" << i << endl;}}cout << "end!" << endl;}A(){ #ifdef _WINDOWSJQ_InitializeCriticalSection(&my_winsec);//用臨界區之前先初始化 #endif}private:std::list<int> msgRecvQueue;//容器（消息隊列），代表玩家發送過來的命令。std::mutex my_mutex;//創建一個互斥量（一把鎖）#ifdef _WINDOWSJQ_CRITICAL_SECTION my_winsec; //windows中的臨界區，非常類似C++11中的互斥量,聲名 #endif }; ``### （2）自動析構技術```c++ //本類用于自動釋放windows下的臨界區，防止忘記LeaveCriticalSection導致死鎖的情況發生， //類似于C++11中的std::lock_guard<std::mutex> class CWinLock //叫RAII類 （resource Acquisition is initialization）“資源獲取即初始化” eg 智能指針類，容器 都屬于RAII類 { public:CWinLock(CRITICAL_SECTION *pCritmp){m_Pcitical = pCritmp;EnterCriticalSection(m_Pcitical);}~CWinLock(){LeaveCriticalSection(m_Pcitical);} private:CRITICAL_SECTION *m_Pcitical; };（3）recursive_mutex遞歸的獨占互斥量
2.1 recursive_mutex遞歸的獨占互斥量
recursive_mutex 遞歸的獨占互斥量：允許同一個線程,同一個互斥量多次被lock，但效率上比mutex更低；遞歸次數據說有限制，遞歸太多可能有異常。
（4）超時互斥量std::timed_mutex和超時遞歸互斥量recursive_timed_mutex
2.2超時互斥量std::timed_mutex
std:: timed_mutex:帶超時功能的獨占互斥量
try_lock_for():等待一段時間，如果拿到了鎖，或者等待超時，沒有拿到鎖，就走下來
try_lock_until();參數是一個未來的時間點，這個未來的時間沒到的時間內，如果我拿到了鎖頭，那么就走下來；如果時間到了，沒拿到鎖，程序的流程也走下來；
2.3超時遞歸互斥量recursive_timed_mutex
std:: recursive_timed_mutex:帶超時功能的遞歸獨占互斥量（允許同一個線程多次獲取這互斥量），用法與std::timed_mutex相同。
附錄
1
(detach) thread mythread(myprint, myi, string(myp));
驗證方法：使用[ 類 ]驗證，調試，觀察主線程執行完畢時，myp是否轉換了類型。
class A { public:int m_i;A(int a):m_i(a){cout<<"構造函數執行"<<endl;}A(const A &a) :m_i(a.m_i){cout<<"拷貝構造函數執行"<<endl;}~A(){cout<<"析構函數執行"<<endl;} };void myprint(const int i, const A &p) {cout << i << endl;cout << &p << endl;//打印p的地址return; }int main() {int myi = 1;int& myii = myi;char myp[] = "I love China!";thread mythread(myprint, myi, A(myp));// ② 陷阱一mythread.detach();return 0; }2
智能指針（c++11）
確保動態分配內存的對象在應該被釋放時，指向它的智能指針可以確保自動的釋放它。
定義在memory頭文件里的三種智能指針類型：
shared_ptr：允許多個指針指向同一個對象。
初始化方法：[ shared_ptr＜數據類型＞｛變量名｝= make_shared＜數據類型＞({數值})；]
unique_str：“獨占”所指向的對象。
不支持拷貝，也不支持拷貝構造函數。
指針所有權傳遞：[ p1.reset(p2.release()); 意為將p2指針所有權給p1，并將p2置為空 ]
weak_ptr：弱引用，指向shared_ptr管理的對象。
3
移動構造函數
移動構造函數是C++11中新增加的一種構造函數
目的：為了解決以往只能復制，而不能轉移而造成的性能消耗。
class A {public:/*...*/A(A && a){ // 移動構造函數 &&：傳入右值std::cout << "A move construct ..." << std::endl;ptr_ = a.ptr_;a.ptr_ = nullptr;}/* ...*/ };move( )函數：將括號中的數據改為右值
意義：使例子中的vector內部通過移動構造函數創建A對象，減少了對堆空間的頻繁操作。
vector<A> vec; vec.push_back(move( A() ));右值和左值（c++11）
右值：指的的臨時值或常量（更準確的說法是保存在CPU寄存器中的值為右值）
左值：是保存在內存中的值。
int a = 5;// 5是右值，a是左值 // int && e = a; 報錯，因為a是左值，無法賦值給右值 int && e = std::move(a); // 正確，使用move()將左值改編為右值通用引用
一，必須是T&&的形式；
二，T類型要可以推導，
所以 auto && b = 5/a; 都可以。（通用引用既可接收左值，又可接收右值）但加了const就不再是通用引用了
疑惑 內嵌類析構
需補充單例模式reorder問題
參考(2條消息) 單例模式出現內存reorder，以及解決_陳九修的博客-CSDN博客
總結
- 上一篇： 首届中国餐饮行业资本品牌创新发展（盐城）
- 下一篇： 团购网站的简单分析