1. 從單核到多核為什么C11的std::thread是游戲規(guī)則的改變者我記得十幾年前剛接觸C多線程編程那會(huì)兒用的還是平臺(tái)相關(guān)的API比如Windows上的CreateThread或者Linux下的pthread_create。那時(shí)候?qū)懣缙脚_(tái)的多線程代碼簡(jiǎn)直是一場(chǎng)噩夢(mèng)到處都是條件編譯代碼里充斥著#ifdef _WIN32。調(diào)試起來更是痛苦線程同步的bug神出鬼沒一個(gè)死鎖能讓你查上好幾天。直到C11標(biāo)準(zhǔn)發(fā)布把std::thread、std::mutex這些家伙納入標(biāo)準(zhǔn)庫(kù)情況才徹底改變。這不僅僅是語法糖而是一次編程范式的升級(jí)它讓多線程編程從“系統(tǒng)黑魔法”變成了“標(biāo)準(zhǔn)庫(kù)常規(guī)操作”。簡(jiǎn)單來說std::thread就是C11標(biāo)準(zhǔn)庫(kù)提供的一個(gè)類用來表示一個(gè)執(zhí)行線程。你創(chuàng)建一個(gè)std::thread對(duì)象就相當(dāng)于向操作系統(tǒng)申請(qǐng)了一個(gè)新的線程并告訴它“去把這段代碼跑起來?！?它的核心價(jià)值在于標(biāo)準(zhǔn)化和可移植性。無論你的代碼最終跑在Windows、Linux還是macOS上只要編譯器支持C11你寫多線程代碼的方式都是一樣的。這極大地降低了學(xué)習(xí)和維護(hù)成本。那么std::thread解決了什么問題首先它抽象了底層操作系統(tǒng)的線程接口提供了統(tǒng)一的C對(duì)象模型來管理線程生命周期。其次它與標(biāo)準(zhǔn)庫(kù)的其他組件如互斥量、條件變量、未來值無縫集成共同構(gòu)成了C標(biāo)準(zhǔn)線程庫(kù)讓并發(fā)編程更安全、更高效。它適合所有需要提升程序性能、實(shí)現(xiàn)異步操作或處理多任務(wù)的C開發(fā)者無論是做服務(wù)器后端的高并發(fā)處理還是客戶端程序的界面響應(yīng)優(yōu)化甚至是游戲引擎中的資源加載都離不開它。2. std::thread的核心機(jī)制與生命周期管理2.1 線程的創(chuàng)建與啟動(dòng)不止一種姿勢(shì)創(chuàng)建一個(gè)線程最基本的方式就是給std::thread構(gòu)造函數(shù)傳遞一個(gè)可調(diào)用對(duì)象。這個(gè)可調(diào)用對(duì)象就是線程的“入口函數(shù)”。1. 使用普通函數(shù)或靜態(tài)成員函數(shù)這是最直接的方式。函數(shù)簽名是什么樣線程就跑什么樣。void helloWorld() { std::cout Hello from thread! Thread ID: std::this_thread::get_id() std::endl; } int main() { std::thread t(helloWorld); // 創(chuàng)建線程并立即執(zhí)行helloWorld // ... 主線程繼續(xù)執(zhí)行其他任務(wù) t.join(); // 等待線程t結(jié)束 return 0; }這里有個(gè)關(guān)鍵細(xì)節(jié)std::thread t(helloWorld);這一行線程對(duì)象t被構(gòu)造出來的瞬間新的執(zhí)行線程就已經(jīng)開始運(yùn)行了。它不是先創(chuàng)建個(gè)“待命”的線程等你下命令。這種“構(gòu)造即啟動(dòng)”的語義需要特別注意。2. 使用Lambda表達(dá)式C11的熱門搭檔Lambda讓線程創(chuàng)建變得異常簡(jiǎn)潔尤其適合需要捕獲局部變量的場(chǎng)景。int main() { std::string localMsg Data from main thread; std::thread t([localMsg]() { // 以引用方式捕獲localMsg std::cout Lambda thread says: localMsg std::endl; // 注意這里訪問localMsg是危險(xiǎn)的因?yàn)閙ain函數(shù)可能先結(jié)束 }); t.join(); return 0; }使用Lambda時(shí)關(guān)于變量捕獲的生命周期管理是重中之重。上面代碼用引用捕獲localMsg就是典型的坑如果main函數(shù)先于線程t結(jié)束localMsg被銷毀線程再去訪問就是未定義行為可能導(dǎo)致程序崩潰。更安全的做法是傳值[localMsg]或者確保主線程等待子線程完成。3. 使用函數(shù)對(duì)象仿函數(shù)通過重載operator()的類來創(chuàng)建線程可以方便地?cái)y帶狀態(tài)。class Task { public: Task(int id) : m_id(id) {} void operator()() const { std::cout Task m_id is running. std::endl; } private: int m_id; }; int main() { std::thread t(Task(42)); // 傳入一個(gè)臨時(shí)Task對(duì)象 t.join(); return 0; }這里容易出錯(cuò)的地方是“最令人煩惱的解析”Most Vexing Parse。如果你寫成std::thread t(Task());編譯器會(huì)認(rèn)為這是一個(gè)函數(shù)聲明而不是創(chuàng)建線程。解決辦法是使用額外的括號(hào)std::thread t((Task()))或者C11的統(tǒng)一初始化std::thread t{Task{}}。4. 使用帶參數(shù)的函數(shù)線程函數(shù)可以接受參數(shù)參數(shù)會(huì)拷貝到線程的內(nèi)部存儲(chǔ)中。void printSum(int a, int b) { std::cout a b (a b) std::endl; } int main() { int x 10, y 20; std::thread t(printSum, x, y); // 參數(shù)x, y會(huì)被拷貝 t.join(); return 0; }需要注意的是所有參數(shù)都會(huì)先被拷貝。即使你傳了一個(gè)引用int線程內(nèi)部得到的也是這個(gè)引用的拷貝即另一個(gè)引用但指向相同對(duì)象。如果你真的希望線程修改主線程中的變量必須使用std::ref進(jìn)行包裝std::thread t(printSum, std::ref(x), y);。注意線程對(duì)象的構(gòu)造是可能拋出異常的。如果系統(tǒng)資源不足例如無法創(chuàng)建新的線程構(gòu)造函數(shù)會(huì)拋出std::system_error異常。在生產(chǎn)代碼中對(duì)std::thread的構(gòu)造進(jìn)行異常處理是良好的習(xí)慣。2.2 線程的匯合與分離你必須做出的選擇線程啟動(dòng)后你必須管理它的結(jié)束。std::thread對(duì)象與底層執(zhí)行線程是兩個(gè)概念。對(duì)象是C層面的資源管理者底層線程是操作系統(tǒng)調(diào)度單元。對(duì)象銷毀前你必須明確告訴它如何處置底層線程。1. 匯合join等待線程完成join()成員函數(shù)會(huì)阻塞調(diào)用它的線程通常是主線程直到被join的線程執(zhí)行完畢。這是最安全、最常用的方式。std::thread t(doWork); // ... 主線程可以做其他事 t.join(); // 主線程在此等待直到doWork線程結(jié)束join()之后std::thread對(duì)象就不再關(guān)聯(lián)任何執(zhí)行線程t.joinable()會(huì)返回false對(duì)象可以被安全銷毀或重新賦值。2. 分離detach放飛線程detach()成員函數(shù)將std::thread對(duì)象與其底層執(zhí)行線程分離。分離后對(duì)象不再擁有該線程線程會(huì)“在后臺(tái)”自主運(yùn)行直到其入口函數(shù)執(zhí)行完畢由運(yùn)行時(shí)庫(kù)負(fù)責(zé)清理資源。std::thread t(doBackgroundTask); t.detach(); // 從此t與doBackgroundTask線程再無瓜葛 // 主線程繼續(xù)不等待doBackgroundTask分離線程非常危險(xiǎn)必須謹(jǐn)慎使用。一旦分離你就失去了對(duì)這個(gè)線程的控制權(quán)。你無法再join它也無法強(qiáng)制終止它。如果主程序main函數(shù)先結(jié)束了而分離的線程還在運(yùn)行那么程序會(huì)直接終止后臺(tái)線程可能被強(qiáng)行殺掉導(dǎo)致資源未釋放如文件未關(guān)閉、內(nèi)存未釋放。3. 析構(gòu)時(shí)的抉擇join還是detach這是std::thread生命周期管理的核心規(guī)則在std::thread對(duì)象析構(gòu)之前它所關(guān)聯(lián)的底層線程必須是“已匯合”joined或“已分離”detached狀態(tài)。如果兩者都不是即joinable() true那么std::thread的析構(gòu)函數(shù)會(huì)調(diào)用std::terminate()整個(gè)程序會(huì)異常終止。這意味著你不能放任一個(gè)joinable的線程對(duì)象不管。常見的做法是使用RAII資源獲取即初始化包裝器。class ThreadGuard { std::thread t; public: explicit ThreadGuard(std::thread t_) : t(t_) {} ~ThreadGuard() { if(t.joinable()) { t.join(); // 在析構(gòu)時(shí)自動(dòng)join確保安全 } } // 禁止拷貝 ThreadGuard(const ThreadGuard)delete; ThreadGuard operator(const ThreadGuard)delete; }; void riskyFunction() { std::thread t(doWork); ThreadGuard g(t); // 守衛(wèi)對(duì)象離開作用域時(shí)自動(dòng)join // ... 即使這里拋出異常g的析構(gòu)也會(huì)被調(diào)用t會(huì)被join // 無需手動(dòng)調(diào)用 t.join(); }C20引入了std::jthreadjoining thread它在析構(gòu)時(shí)會(huì)自動(dòng)join是更現(xiàn)代、更安全的選擇。但在C11/14/17中我們必須自己注意這個(gè)生命周期問題。2.3 線程標(biāo)識(shí)與硬件并發(fā)數(shù)每個(gè)執(zhí)行線程都有一個(gè)唯一的標(biāo)識(shí)符類型是std::thread::id?？梢酝ㄟ^std::this_thread::get_id()獲取當(dāng)前線程的ID或通過std::thread對(duì)象的get_id()成員函數(shù)獲取其關(guān)聯(lián)線程的ID。std::thread::id可以比較相等性、排序用于容器也可以輸出到流。它在調(diào)試多線程問題時(shí)非常有用可以打印日志來區(qū)分是哪個(gè)線程在執(zhí)行。另一個(gè)有用的工具是std::thread::hardware_concurrency()它是一個(gè)靜態(tài)成員函數(shù)返回當(dāng)前硬件支持的并發(fā)線程數(shù)通常是CPU的核心數(shù)或超線程數(shù)。這個(gè)值是一個(gè)提示用于指導(dǎo)我們創(chuàng)建“合適”數(shù)量的線程避免創(chuàng)建遠(yuǎn)多于核心數(shù)的線程導(dǎo)致過多的上下文切換開銷。unsigned int n std::thread::hardware_concurrency(); std::cout This machine supports about n concurrent threads. std::endl;注意這個(gè)函數(shù)可能返回0如果信息不可用的話。所以用它做除數(shù)前要判斷。3. 線程間的數(shù)據(jù)共享與同步從混亂到秩序多個(gè)線程同時(shí)運(yùn)行如果它們完全獨(dú)立那世界就簡(jiǎn)單了。但現(xiàn)實(shí)是線程間經(jīng)常需要通信和共享數(shù)據(jù)。不加保護(hù)地訪問共享數(shù)據(jù)是導(dǎo)致多線程程序崩潰、結(jié)果錯(cuò)誤競(jìng)態(tài)條件的根源。C11提供了一整套同步原語來建立秩序。3.1 互斥量std::mutex基礎(chǔ)的鎖互斥量Mutual Exclusion是最基本的同步工具。它像一個(gè)房間的鑰匙一次只允許一個(gè)線程進(jìn)入“臨界區(qū)”訪問共享數(shù)據(jù)的代碼段。1. 基本用法std::mutex g_mutex; int shared_data 0; void safe_increment() { g_mutex.lock(); shared_data; // 臨界區(qū) g_mutex.unlock(); }但直接使用lock()和unlock()是危險(xiǎn)的。如果在lock()和unlock()之間拋出了異常或者程序員忘記調(diào)用unlock()鎖就永遠(yuǎn)不會(huì)被釋放導(dǎo)致其他線程永久等待死鎖。所以永遠(yuǎn)不要直接調(diào)用lock()和unlock()。2. 鎖守衛(wèi)std::lock_guardRAII的救贖std::lock_guard是一個(gè)模板類它在構(gòu)造時(shí)鎖定互斥量在析構(gòu)時(shí)自動(dòng)解鎖。利用RAII即使臨界區(qū)代碼拋出異常鎖也能被正確釋放。void safe_increment_better() { std::lock_guardstd::mutex lock(g_mutex); // 構(gòu)造時(shí)加鎖 shared_data; // 臨界區(qū) } // lock對(duì)象析構(gòu)自動(dòng)解鎖簡(jiǎn)單、安全、無腦。對(duì)于絕大多數(shù)簡(jiǎn)單的臨界區(qū)保護(hù)std::lock_guard是首選。3. 唯一鎖std::unique_lock更靈活的守衛(wèi)std::unique_lock比std::lock_guard更靈活但代價(jià)是稍大的開銷。它允許延遲鎖定、嘗試鎖定、手動(dòng)解鎖和轉(zhuǎn)移所有權(quán)。std::mutex mtx; std::unique_lockstd::mutex lock(mtx, std::defer_lock); // 延遲鎖定現(xiàn)在未鎖 // ... 做一些不需要鎖的操作 lock.lock(); // 現(xiàn)在才鎖定 // ... 操作共享數(shù)據(jù) lock.unlock(); // 可以手動(dòng)提前解鎖 // ... 做一些不需要鎖的操作 lock.lock(); // 再次鎖定unique_lock允許重新鎖定std::unique_lock的典型應(yīng)用場(chǎng)景是配合條件變量std::condition_variable因?yàn)闂l件變量的wait函數(shù)需要一個(gè)std::unique_lock參數(shù)。4. 其他類型的互斥量std::timed_mutex/std::recursive_timed_mutex除了基本鎖定還提供try_lock_for和try_lock_until嘗試鎖定一段時(shí)間超時(shí)則返回false避免無限期阻塞。std::recursive_mutex允許同一個(gè)線程多次鎖定同一個(gè)互斥量。常用于遞歸函數(shù)中。但使用遞歸鎖通常意味著設(shè)計(jì)有問題應(yīng)優(yōu)先考慮重構(gòu)代碼。3.2 條件變量std::condition_variable線程間的通知機(jī)制互斥量解決了互斥訪問但線程間經(jīng)常需要等待某個(gè)條件成立。比如消費(fèi)者線程需要等待隊(duì)列不為空。忙等待不斷循環(huán)檢查條件會(huì)浪費(fèi)CPU。條件變量提供了高效的等待/通知機(jī)制。一個(gè)條件變量總是與一個(gè)互斥量和一個(gè)條件通常是共享數(shù)據(jù)的某個(gè)狀態(tài)一起使用。std::mutex mtx; std::condition_variable cv; std::queueint data_queue; bool finished false; // 生產(chǎn)者線程 void producer() { for(int i0; i10; i) { std::this_thread::sleep_for(std::chrono::milliseconds(100)); { std::lock_guardstd::mutex lock(mtx); data_queue.push(i); std::cout Produced: i std::endl; } cv.notify_one(); // 通知一個(gè)等待的消費(fèi)者 } { std::lock_guardstd::mutex lock(mtx); finished true; } cv.notify_all(); // 通知所有消費(fèi)者結(jié)束 } // 消費(fèi)者線程 void consumer() { while(true) { std::unique_lockstd::mutex lock(mtx); // wait會(huì)在阻塞前自動(dòng)解鎖mtx并在返回前重新鎖定mtx cv.wait(lock, []{ return !data_queue.empty() || finished; }); if(finished data_queue.empty()) { break; // 生產(chǎn)結(jié)束且隊(duì)列空退出循環(huán) } int value data_queue.front(); data_queue.pop(); lock.unlock(); // 可以提前解鎖讓其他線程操作隊(duì)列 std::cout Consumed: value std::endl; // 處理value... } }關(guān)鍵點(diǎn)解析cv.wait(lock, predicate)這是帶謂詞的等待。它等價(jià)于while(!predicate()) { cv.wait(lock); }這個(gè)循環(huán)是必要的以防止“虛假喚醒”spurious wakeup——即線程在沒有被notify的情況下從wait中返回。謂詞lambda表達(dá)式檢查我們真正等待的條件隊(duì)列非空或生產(chǎn)結(jié)束。在調(diào)用wait時(shí)lock必須是已鎖定的狀態(tài)。wait函數(shù)會(huì)原子地解鎖互斥量并將線程掛起。當(dāng)被notify喚醒時(shí)它會(huì)重新獲取鎖可能會(huì)阻塞直到鎖可用然后檢查謂詞。notify_one()喚醒一個(gè)等待線程任意一個(gè)notify_all()喚醒所有等待該條件變量的線程。判斷條件如!data_queue.empty()和修改共享數(shù)據(jù)data_queue.pop()必須在同一個(gè)鎖的保護(hù)下否則會(huì)有競(jìng)態(tài)條件。3.3 原子操作std::atomic無鎖編程的利器對(duì)于簡(jiǎn)單的計(jì)數(shù)器、標(biāo)志位使用互斥量顯得殺雞用牛刀開銷太大。std::atomic模板提供了不可分割的原子的讀寫操作無需顯式加鎖通常由硬件指令直接支持效率極高。std::atomicint counter(0); // 原子整數(shù) void increment_atomic() { for(int i0; i1000; i) { counter; // 原子自增 // 等價(jià)于 counter.fetch_add(1, std::memory_order_relaxed); } } int main() { std::thread t1(increment_atomic); std::thread t2(increment_atomic); t1.join(); t2.join(); std::cout Counter counter std::endl; // 一定是2000 return 0; }std::atomic支持整型、指針類型以及std::atomicbool。對(duì)于自定義類型如果滿足“可平凡復(fù)制”等條件也可以特化但復(fù)雜類型的原子操作可能內(nèi)部使用鎖。內(nèi)存序Memory Order這是std::atomic的高級(jí)話題也是難點(diǎn)。原子操作除了保證操作的原子性還影響內(nèi)存訪問的排序可見性。std::memory_order枚舉定義了不同嚴(yán)格級(jí)別的內(nèi)存序memory_order_seq_cst順序一致性默認(rèn)選項(xiàng)最強(qiáng)保證性能開銷最大。所有線程看到的操作順序一致。memory_order_relaxed松散順序只保證原子性不保證順序。性能最好但需要程序員非常清楚數(shù)據(jù)依賴關(guān)系。memory_order_acquire/memory_order_release/memory_order_acq_rel用于實(shí)現(xiàn)“同步-與”關(guān)系是高性能并發(fā)數(shù)據(jù)結(jié)構(gòu)如鎖、無鎖隊(duì)列的基礎(chǔ)。對(duì)于初學(xué)者使用默認(rèn)的memory_order_seq_cst是最安全的選擇。只有在追求極致性能、且深刻理解內(nèi)存模型后才考慮使用更寬松的內(nèi)存序。3.4 線程局部存儲(chǔ)thread_local有時(shí)你需要一個(gè)變量每個(gè)線程都有自己獨(dú)立的一份拷貝互不干擾。這就是線程局部存儲(chǔ)TLS。C11引入了thread_local關(guān)鍵字。thread_local int thread_specific_value 0; void thread_func(int id) { thread_specific_value id; // 每個(gè)線程修改自己的副本 std::this_thread::sleep_for(std::chrono::seconds(1)); std::cout Thread id : value thread_specific_value std::endl; } int main() { std::thread t1(thread_func, 1); std::thread t2(thread_func, 2); t1.join(); t2.join(); // 輸出可能是 // Thread 1: value 1 // Thread 2: value 2 // 兩個(gè)線程的thread_specific_value是獨(dú)立的。 return 0; }thread_local可以用于全局變量、局部靜態(tài)變量、類靜態(tài)成員變量。它常用于存儲(chǔ)線程ID、隨機(jī)數(shù)生成器、數(shù)據(jù)庫(kù)連接等需要線程隔離的資源。注意thread_local變量的初始化是惰性的首次使用時(shí)初始化并且每個(gè)線程初始化一次。4. 高級(jí)主題與實(shí)戰(zhàn)模式掌握了基礎(chǔ)我們來看看如何用這些工具構(gòu)建更可靠、更高效的多線程程序。4.1 線程安全的數(shù)據(jù)結(jié)構(gòu)設(shè)計(jì)以線程安全隊(duì)列為例設(shè)計(jì)一個(gè)線程安全的隊(duì)列是經(jīng)典的面試題也是理解同步的絕佳例子。目標(biāo)是多個(gè)線程可以安全地同時(shí)進(jìn)行入隊(duì)push和出隊(duì)pop操作。一個(gè)簡(jiǎn)單的版本使用粗粒度鎖templatetypename T class ThreadSafeQueue { private: mutable std::mutex mtx; std::queueT data_queue; std::condition_variable data_cond; public: ThreadSafeQueue() default; void push(T new_value) { std::lock_guardstd::mutex lock(mtx); data_queue.push(std::move(new_value)); data_cond.notify_one(); } // 嘗試彈出立即返回 bool try_pop(T value) { std::lock_guardstd::mutex lock(mtx); if(data_queue.empty()) { return false; } value std::move(data_queue.front()); data_queue.pop(); return true; } // 等待并彈出 void wait_and_pop(T value) { std::unique_lockstd::mutex lock(mtx); data_cond.wait(lock, [this]{ return !data_queue.empty(); }); value std::move(data_queue.front()); data_queue.pop(); } std::shared_ptrT wait_and_pop() { std::unique_lockstd::mutex lock(mtx); data_cond.wait(lock, [this]{ return !data_queue.empty(); }); std::shared_ptrT res(std::make_sharedT(std::move(data_queue.front()))); data_queue.pop(); return res; } bool empty() const { std::lock_guardstd::mutex lock(mtx); return data_queue.empty(); } };設(shè)計(jì)要點(diǎn)鎖的粒度整個(gè)隊(duì)列用一個(gè)互斥量mtx保護(hù)。簡(jiǎn)單但并發(fā)度不高。更高級(jí)的設(shè)計(jì)可以對(duì)頭尾使用不同的鎖。條件變量的使用wait_and_pop提供了阻塞等待功能適合消費(fèi)者模型。異常安全使用std::lock_guard和std::unique_lock確保即使push或pop中發(fā)生異常鎖也能釋放。移動(dòng)語義參數(shù)和返回值使用std::move避免不必要的拷貝提高效率。接口設(shè)計(jì)提供了try_pop非阻塞和wait_and_pop阻塞兩種方式適應(yīng)不同場(chǎng)景。4.2 異步操作與Future/Promise模式有時(shí)我們不想手動(dòng)管理線程而是想“提交一個(gè)任務(wù)并在未來某個(gè)時(shí)刻獲取結(jié)果”。C11提供了std::async、std::future和std::promise來實(shí)現(xiàn)這種模式。1. 使用std::asyncstd::async啟動(dòng)一個(gè)異步任務(wù)返回一個(gè)std::future對(duì)象用于在未來獲取結(jié)果。#include future #include iostream int computeHeavyTask(int x) { std::this_thread::sleep_for(std::chrono::seconds(2)); return x * x; } int main() { // 啟動(dòng)異步任務(wù)可能在新線程中執(zhí)行也可能延遲執(zhí)行由實(shí)現(xiàn)決定 std::futureint fut std::async(std::launch::async, computeHeavyTask, 10); std::cout Main thread can do other work here...\n; // 獲取結(jié)果。如果任務(wù)未完成會(huì)阻塞等待。 int result fut.get(); std::cout Result is: result std::endl; // 輸出 100 return 0; }std::async的第一個(gè)參數(shù)是啟動(dòng)策略std::launch::async強(qiáng)制在新線程中異步執(zhí)行。std::launch::deferred延遲執(zhí)行直到在future上調(diào)用get()或wait()時(shí)才在當(dāng)前線程同步執(zhí)行。std::launch::async | std::launch::deferred默認(rèn)由實(shí)現(xiàn)選擇可能是異步也可能是延遲。2. 使用std::promise和std::futurestd::promise和std::future是一對(duì)用于在線程間傳遞一個(gè)值或異常。void doWork(std::promiseint prom) { std::this_thread::sleep_for(std::chrono::seconds(1)); prom.set_value(42); // 設(shè)置結(jié)果 // 如果發(fā)生異常prom.set_exception(std::current_exception()); } int main() { std::promiseint prom; std::futureint fut prom.get_future(); // 從promise獲取關(guān)聯(lián)的future std::thread t(doWork, std::move(prom)); // promise不可拷貝只能移動(dòng) // 在主線程做其他事... int value fut.get(); // 阻塞直到promise設(shè)置值 std::cout The answer is: value std::endl; t.join(); return 0; }std::promise/std::future比std::async更底層也更靈活。你可以將promise對(duì)象傳遞給一個(gè)線程讓該線程在完成任務(wù)后通過promise設(shè)置結(jié)果而另一個(gè)線程則通過關(guān)聯(lián)的future來等待并獲取這個(gè)結(jié)果。一個(gè)promise只能設(shè)置一次值。3. 使用std::packaged_taskstd::packaged_task包裝一個(gè)可調(diào)用對(duì)象使其可以異步執(zhí)行并通過future獲取結(jié)果。它像一個(gè)可移動(dòng)的函數(shù)對(duì)象內(nèi)部包含了一個(gè)promise。int complexCalculation(int a, int b) { return a * a b * b; } int main() { // 將函數(shù)包裝成packaged_task std::packaged_taskint(int, int) task(complexCalculation); // 獲取與任務(wù)關(guān)聯(lián)的future std::futureint fut task.get_future(); // 將任務(wù)移動(dòng)到線程中執(zhí)行 std::thread t(std::move(task), 3, 4); // 獲取結(jié)果 int result fut.get(); // 25 std::cout Result: result std::endl; t.join(); return 0; }std::packaged_task非常適合將任務(wù)放入隊(duì)列由線程池中的工作線程取出執(zhí)行。4.3 線程池的基本思想雖然C11標(biāo)準(zhǔn)庫(kù)沒有直接提供線程池但我們可以用已有的工具構(gòu)建一個(gè)簡(jiǎn)單的版本。線程池的核心思想是預(yù)先創(chuàng)建一組線程工作線程它們從一個(gè)任務(wù)隊(duì)列中不斷取出任務(wù)并執(zhí)行。主線程或任何線程只需將任務(wù)提交到隊(duì)列而無需頻繁創(chuàng)建和銷毀線程避免了線程創(chuàng)建銷毀的開銷。一個(gè)極簡(jiǎn)線程池的框架class SimpleThreadPool { public: SimpleThreadPool(size_t thread_count std::thread::hardware_concurrency()) { for(size_t i0; ithread_count; i) { workers.emplace_back([this] { while(true) { std::functionvoid() task; { std::unique_lockstd::mutex lock(queue_mutex); condition.wait(lock, [this]{ return stop || !tasks.empty(); }); if(stop tasks.empty()) { return; // 線程退出 } task std::move(tasks.front()); tasks.pop(); } task(); // 執(zhí)行任務(wù) } }); } } templateclass F void enqueue(F f) { { std::lock_guardstd::mutex lock(queue_mutex); tasks.emplace(std::forwardF(f)); } condition.notify_one(); // 通知一個(gè)工作線程 } ~SimpleThreadPool() { { std::lock_guardstd::mutex lock(queue_mutex); stop true; } condition.notify_all(); // 通知所有線程退出 for(std::thread worker: workers) { worker.join(); } } private: std::vectorstd::thread workers; std::queuestd::functionvoid() tasks; std::mutex queue_mutex; std::condition_variable condition; bool stop false; };使用方式SimpleThreadPool pool(4); // 創(chuàng)建4個(gè)工作線程 // 提交任務(wù) pool.enqueue([]{ std::cout Task 1\n; }); pool.enqueue([]{ std::cout Task 2\n; }); // 主線程可以繼續(xù)做其他事... // 析構(gòu)時(shí)pool會(huì)自動(dòng)等待所有任務(wù)完成并join所有工作線程。這個(gè)簡(jiǎn)單線程池省略了異常處理、返回future、動(dòng)態(tài)調(diào)整線程數(shù)等高級(jí)功能但展示了核心原理任務(wù)隊(duì)列、工作線程循環(huán)、條件變量同步。5. 避坑指南與性能調(diào)優(yōu)實(shí)戰(zhàn)多線程編程陷阱無數(shù)下面是一些血淚教訓(xùn)總結(jié)出的核心要點(diǎn)。5.1 死鎖成因與破解之道死鎖通常發(fā)生在兩個(gè)或多個(gè)線程互相等待對(duì)方釋放鎖時(shí)。四個(gè)必要條件互斥、持有并等待、不可剝奪、循環(huán)等待。典型死鎖場(chǎng)景std::mutex mtx1, mtx2; void thread_a() { std::lock_guardstd::mutex lock1(mtx1); std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 增加死鎖概率 std::lock_guardstd::mutex lock2(mtx2); // 等待mtx2但可能被thread_b持有 // ... } void thread_b() { std::lock_guardstd::mutex lock2(mtx2); std::this_thread::sleep_for(std::chrono::milliseconds(10)); std::lock_guardstd::mutex lock1(mtx1); // 等待mtx1但可能被thread_a持有 // ... }解決方案固定鎖順序所有線程以相同的順序獲取鎖。例如規(guī)定必須先鎖mtx1再鎖mtx2。使用std::lock一次性鎖定多個(gè)互斥量C11提供了std::lock函數(shù)可以一次性鎖定兩個(gè)或更多互斥量且避免死鎖內(nèi)部使用算法如Dijkstra的銀行家算法。void safe_transaction() { std::unique_lockstd::mutex lock1(mtx1, std::defer_lock); std::unique_lockstd::mutex lock2(mtx2, std::defer_lock); std::lock(lock1, lock2); // 一次性鎖定不會(huì)死鎖 // ... 操作受保護(hù)的數(shù)據(jù) }避免嵌套鎖如果設(shè)計(jì)允許盡量減少鎖的持有范圍避免在一個(gè)鎖的保護(hù)下去獲取另一個(gè)鎖。使用層次鎖為鎖分配層次編號(hào)線程只能獲取比當(dāng)前持有鎖層次更低的鎖。5.2 數(shù)據(jù)競(jìng)爭(zhēng)與競(jìng)態(tài)條件數(shù)據(jù)競(jìng)爭(zhēng)Data Race是指多個(gè)線程在沒有同步的情況下同時(shí)訪問同一個(gè)內(nèi)存位置且至少有一個(gè)是寫操作。競(jìng)態(tài)條件Race Condition更廣義指程序的結(jié)果依賴于線程執(zhí)行的相對(duì)時(shí)序。一個(gè)隱蔽的競(jìng)態(tài)條件例子std::vectorint vec; void maybe_bad() { if(!vec.empty()) { // ① 檢查 std::cout vec.back() std::endl; // ② 訪問 vec.pop_back(); // ③ 修改 } }如果兩個(gè)線程同時(shí)調(diào)用maybe_bad可能發(fā)生線程A執(zhí)行①發(fā)現(xiàn)vec非空。線程B執(zhí)行①也發(fā)現(xiàn)vec非空。線程A執(zhí)行②打印最后一個(gè)元素。線程B執(zhí)行②也打印最后一個(gè)元素和A相同。線程A執(zhí)行③pop_back。線程B執(zhí)行③pop_back但此時(shí)vec可能已空如果原來只有一個(gè)元素導(dǎo)致未定義行為。解決方法將檢查、訪問、修改三個(gè)操作作為一個(gè)整體用鎖保護(hù)。std::mutex vec_mtx; void good() { std::lock_guardstd::mutex lock(vec_mtx); if(!vec.empty()) { std::cout vec.back() std::endl; vec.pop_back(); } }5.3 性能陷阱與優(yōu)化建議鎖的粒度鎖住太多數(shù)據(jù)或太長(zhǎng)時(shí)間粗粒度鎖會(huì)嚴(yán)重降低并發(fā)性。盡量縮小臨界區(qū)范圍只鎖住必須共享的數(shù)據(jù)。避免在鎖內(nèi)進(jìn)行耗時(shí)操作如I/O操作、網(wǎng)絡(luò)請(qǐng)求、復(fù)雜計(jì)算等。這會(huì)導(dǎo)致其他線程長(zhǎng)時(shí)間等待。警惕鎖爭(zhēng)用Lock Contention當(dāng)大量線程頻繁競(jìng)爭(zhēng)同一把鎖時(shí)性能會(huì)急劇下降。解決方案包括使用更細(xì)粒度的鎖例如為哈希表的每個(gè)桶配備獨(dú)立的鎖。使用無鎖數(shù)據(jù)結(jié)構(gòu)基于std::atomic和內(nèi)存序?qū)崿F(xiàn)但開發(fā)難度極高。使用讀寫鎖C14的std::shared_timed_mutexC17的std::shared_mutex允許多個(gè)讀者同時(shí)訪問但寫者獨(dú)占。std::shared_mutex rw_mutex; // 讀者線程 { std::shared_lockstd::shared_mutex lock(rw_mutex); // 共享鎖 // 讀取數(shù)據(jù)... } // 寫者線程 { std::unique_lockstd::shared_mutex lock(rw_mutex); // 獨(dú)占鎖 // 修改數(shù)據(jù)... }線程數(shù)量不是越多越好創(chuàng)建超過CPU核心數(shù)的線程會(huì)導(dǎo)致大量上下文切換開銷。通常線程數(shù) CPU核心數(shù)或CPU核心數(shù) 1是較好的起點(diǎn)。對(duì)于I/O密集型任務(wù)可以適當(dāng)增加。使用線程局部存儲(chǔ)減少同步如果數(shù)據(jù)不需要在線程間共享使用thread_local可以完全避免鎖。測(cè)量而不是猜測(cè)使用性能分析工具如perf, VTune, 各種profiler來定位多線程程序中的熱點(diǎn)和鎖爭(zhēng)用點(diǎn)。優(yōu)化前先測(cè)量?jī)?yōu)化后再測(cè)量驗(yàn)證。5.4 調(diào)試多線程程序調(diào)試多線程程序是痛苦的。一些有用的技巧使用日志在每個(gè)關(guān)鍵步驟打印線程ID和時(shí)間戳。這是最原始但最有效的方法之一。利用斷言assert在調(diào)試版本中可以幫助發(fā)現(xiàn)不變量被破壞的情況。工具輔助Valgrind Helgrind / DRD檢測(cè)數(shù)據(jù)競(jìng)爭(zhēng)、死鎖等。ThreadSanitizer (TSan)Clang/GCC編譯器提供的運(yùn)行時(shí)數(shù)據(jù)競(jìng)爭(zhēng)檢測(cè)工具在編譯時(shí)添加-fsanitizethread即可。gdb / lldb支持多線程調(diào)試可以查看所有線程的堆棧切換線程。代碼審查多線程代碼需要格外仔細(xì)的審查重點(diǎn)關(guān)注鎖的順序、共享數(shù)據(jù)的訪問、生命周期管理。6. 從C11到C14/17/20線程庫(kù)的演進(jìn)C11奠定了標(biāo)準(zhǔn)線程庫(kù)的基礎(chǔ)后續(xù)標(biāo)準(zhǔn)在此基礎(chǔ)上進(jìn)行了增強(qiáng)。C14主要是小改進(jìn)和缺陷修復(fù)例如為std::chrono增加了std::chrono::literals字面量讓時(shí)間表達(dá)更直觀std::this_thread::sleep_for(500ms)。C17std::shared_mutex非定時(shí)的讀寫鎖比std::shared_timed_mutex性能稍好。并行算法在algorithm頭文件中許多標(biāo)準(zhǔn)算法如std::sort,std::for_each增加了執(zhí)行策略參數(shù)可以指定并行執(zhí)行。std::vectorint v {...}; std::sort(std::execution::par, v.begin(), v.end()); // 可能并行排序std::scoped_lock用于同時(shí)鎖定多個(gè)互斥量的RAII包裝器比std::lock_guard更強(qiáng)大是C17中鎖定多個(gè)互斥量的推薦方式。std::mutex mtx1, mtx2; { std::scoped_lock lock(mtx1, mtx2); // 構(gòu)造時(shí)鎖定mtx1和mtx2析構(gòu)時(shí)按相反順序解鎖 // 臨界區(qū) }C20std::jthread可匯合線程joining thread。最大的改進(jìn)是析構(gòu)時(shí)自動(dòng)join無需手動(dòng)管理解決了C11中std::thread容易因忘記join或detach而導(dǎo)致程序終止的問題。它還支持協(xié)作式中斷通過request_stop()。{ std::jthread t([]{ while(!std::this_thread::stop_requested()) { // 執(zhí)行任務(wù)... } }); } // 離開作用域t自動(dòng)join安全信號(hào)量std::counting_semaphore、鎖存器std::latch、屏障std::barrier更豐富的線程同步機(jī)制。協(xié)程Coroutines語言級(jí)別的支持為異步編程提供了全新的模型雖然不屬于線程庫(kù)但深刻影響了并發(fā)編程的方式。7. 實(shí)戰(zhàn)一個(gè)簡(jiǎn)單的多線程日志器最后我們用一個(gè)綜合例子——一個(gè)簡(jiǎn)單的多線程日志器——來串聯(lián)所學(xué)知識(shí)。這個(gè)日志器需要滿足多個(gè)線程可以同時(shí)向其寫入日志而不會(huì)互相干擾且日志輸出不會(huì)交錯(cuò)。#include iostream #include fstream #include string #include thread #include mutex #include vector #include sstream #include iomanip #include chrono class ThreadSafeLogger { public: // 獲取單例實(shí)例簡(jiǎn)單實(shí)現(xiàn)非線程安全的單例僅示例 static ThreadSafeLogger instance() { static ThreadSafeLogger logger; return logger; } void log(const std::string message, const std::string level INFO) { std::lock_guardstd::mutex lock(mtx_); auto now std::chrono::system_clock::now(); auto now_time_t std::chrono::system_clock::to_time_t(now); auto now_ms std::chrono::duration_caststd::chrono::milliseconds( now.time_since_epoch()) % 1000; std::stringstream ss; ss std::put_time(std::localtime(now_time_t), %Y-%m-%d %H:%M:%S); ss . std::setfill(0) std::setw(3) now_ms.count(); ss [ level ] [Thread: std::this_thread::get_id() ] ; ss message std::endl; // 輸出到控制臺(tái) std::cout ss.str(); // 輸出到文件 if(file_.is_open()) { file_ ss.str(); file_.flush(); // 及時(shí)刷新防止日志丟失 } } void setLogFile(const std::string filename) { std::lock_guardstd::mutex lock(mtx_); if(file_.is_open()) { file_.close(); } file_.open(filename, std::ios::app); } private: ThreadSafeLogger() { // 默認(rèn)日志文件 file_.open(app.log, std::ios::app); } ~ThreadSafeLogger() { if(file_.is_open()) { file_.close(); } } // 禁止拷貝 ThreadSafeLogger(const ThreadSafeLogger) delete; ThreadSafeLogger operator(const ThreadSafeLogger) delete; std::mutex mtx_; std::ofstream file_; }; // 使用宏方便調(diào)用可選 #define LOG_INFO(msg) ThreadSafeLogger::instance().log(msg, INFO) #define LOG_WARN(msg) ThreadSafeLogger::instance().log(msg, WARN) #define LOG_ERROR(msg) ThreadSafeLogger::instance().log(msg, ERROR) void worker(int id) { for(int i0; i5; i) { std::this_thread::sleep_for(std::chrono::milliseconds(100 * id)); LOG_INFO(Worker std::to_string(id) processing task std::to_string(i)); } } int main() { ThreadSafeLogger::instance().setLogFile(myapp.log); LOG_INFO(Application started.); std::vectorstd::thread threads; for(int i0; i4; i) { threads.emplace_back(worker, i1); } for(auto t : threads) { t.join(); } LOG_INFO(All workers finished.); return 0; }這個(gè)日志器雖然簡(jiǎn)單但體現(xiàn)了多線程編程的幾個(gè)關(guān)鍵點(diǎn)線程安全使用一個(gè)互斥量mtx_保護(hù)所有對(duì)共享資源這里是輸出流std::cout和文件file_的訪問。RAII管理鎖使用std::lock_guard確保在任何出口包括異常都能釋放鎖。時(shí)間戳和線程ID每條日志都包含精確時(shí)間和產(chǎn)生它的線程ID便于調(diào)試。文件操作日志同時(shí)輸出到控制臺(tái)和文件并即時(shí)刷新文件緩沖區(qū)防止程序崩潰時(shí)丟失最后幾條日志。單例模式提供一個(gè)全局唯一的訪問點(diǎn)。注意這里的單例實(shí)現(xiàn)Meyers Singleton在C11之后是線程安全的因?yàn)殪o態(tài)局部變量的初始化是線程安全的。在實(shí)際項(xiàng)目中你可能會(huì)考慮使用更高效的雙緩沖隊(duì)列、異步寫入、日志級(jí)別過濾、日志文件滾動(dòng)等高級(jí)功能但核心的線程安全同步機(jī)制是相通的。多線程編程是一條充滿挑戰(zhàn)但回報(bào)豐厚的道路。std::thread及其配套工具為你提供了強(qiáng)大而標(biāo)準(zhǔn)的基礎(chǔ)設(shè)施。從理解線程生命周期和同步原語開始逐步練習(xí)設(shè)計(jì)線程安全的數(shù)據(jù)結(jié)構(gòu)最后掌握更高級(jí)的模式和性能調(diào)優(yōu)技巧。記住謹(jǐn)慎對(duì)待共享數(shù)據(jù)明確鎖的職責(zé)多用RAII管理資源并且永遠(yuǎn)不要停止測(cè)試。