這篇文章主要介紹了C++多線程編程時(shí)的數(shù)據(jù)保護(hù),作者針對(duì)C++11版本中的新特性做出了一些解說(shuō),需要的朋友可以參考下

在編寫(xiě)多線程程序時(shí)，多個(gè)線程同時(shí)訪問(wèn)某個(gè)共享資源，會(huì)導(dǎo)致同步的問(wèn)題，這篇文章中我們將介紹 C++11 多線程編程中的數(shù)據(jù)保護(hù)。

數(shù)據(jù)丟失

讓我們從一個(gè)簡(jiǎn)單的例子開(kāi)始，請(qǐng)看如下代碼：

1. #include <iostream> 
2. #include <string> 
3. #include <thread> 
4. #include <vector> 
5.  
6. using std::thread; 
7. using std::vector; 
8. using std::cout; 
9. using std::endl; 
10.  
11. class Incrementer 
12. { 
13. private: 
14. int counter; 
15.  
16. public: 
17. Incrementer() : counter{0} { }; 
18.  
19. void operator()() 
20. { 
21. for(int i = 0; i < 100000; i++) 
22. { 
23. this->counter++; 
24. } 
25. } 
26.  
27. int getCounter() const 
28. { 
29. return this->counter; 
30. }  
31. }; 
32.  
33. int main() 
34. { 
35. // Create the threads which will each do some counting 
36. vector<thread> threads; 
37.  
38. Incrementer counter; 
39.  
40. threads.push_back(thread(std::ref(counter))); 
41. threads.push_back(thread(std::ref(counter))); 
42. threads.push_back(thread(std::ref(counter))); 
43.  
44. for(auto &t : threads) 
45. { 
46. t.join(); 
47. } 
48.  
49. cout << counter.getCounter() << endl; 
50.  
51. return 0; 
52. } 

這個(gè)程序的目的就是數(shù)數(shù)，數(shù)到30萬(wàn)，某些傻叉程序員想要優(yōu)化數(shù)數(shù)的過(guò)程，因此創(chuàng)建了三個(gè)線程，使用一個(gè)共享變量 counter，每個(gè)線程負(fù)責(zé)給這個(gè)變量增加10萬(wàn)計(jì)數(shù)。

這段代碼創(chuàng)建了一個(gè)名為 Incrementer 的類，該類包含一個(gè)私有變量 counter，其構(gòu)造器非常簡(jiǎn)單，只是將 counter 設(shè)置為 0.

緊接著是一個(gè)操作符重載，這意味著這個(gè)類的每個(gè)實(shí)例都是被當(dāng)作一個(gè)簡(jiǎn)單函數(shù)來(lái)調(diào)用的。一般我們調(diào)用類的某個(gè)方法時(shí)會(huì)這樣 object.fooMethod()，但現(xiàn)在你實(shí)際上是直接調(diào)用了對(duì)象，如object(). 因?yàn)槲覀兪窃诓僮鞣剌d函數(shù)中將整個(gè)對(duì)象傳遞給了線程類。最后是一個(gè) getCounter 方法，返回 counter 變量的值。

再下來(lái)是程序的入口函數(shù) main()，我們創(chuàng)建了三個(gè)線程，不過(guò)只創(chuàng)建了一個(gè) Incrementer 類的實(shí)例，然后將這個(gè)實(shí)例傳遞給三個(gè)線程，注意這里使用了 std::ref ，這相當(dāng)于是傳遞了實(shí)例的引用對(duì)象，而不是對(duì)象的拷貝。

現(xiàn)在讓我們來(lái)看看程序執(zhí)行的結(jié)果，如果這位傻叉程序員還夠聰明的話，他會(huì)使用 GCC 4.7 或者更新版本，或者是 Clang 3.1 來(lái)進(jìn)行編譯，編譯方法：

1. g++ -std=c++11 -lpthread -o threading_example main.cpp 

運(yùn)行結(jié)果：

1. [lucas@lucas-desktop src]$ ./threading_example 
2. 218141 
3. [lucas@lucas-desktop src]$ ./threading_example 
4. 208079 
5. [lucas@lucas-desktop src]$ ./threading_example 
6. 100000 
7. [lucas@lucas-desktop src]$ ./threading_example 
8. 202426 
9. [lucas@lucas-desktop src]$ ./threading_example 
10. 172209 

但等等，不對(duì)啊，程序并沒(méi)有數(shù)數(shù)到30萬(wàn)，有一次居然只數(shù)到10萬(wàn)，為什么會(huì)這樣呢?好吧，加1操作對(duì)應(yīng)實(shí)際的處理器指令其實(shí)包括：

1. movl counter(%rip), %eax 
2. addl $1, %eax 
3. movl %eax, counter(%rip) 

首個(gè)指令將裝載 counter 的值到 %eax 寄存器，緊接著寄存器的值增1，然后將寄存器的值移給內(nèi)存中 counter 所在的地址。

我聽(tīng)到你在嘀咕：這不錯(cuò)，可為什么會(huì)導(dǎo)致數(shù)數(shù)錯(cuò)誤的問(wèn)題呢?嗯，還記得我們以前說(shuō)過(guò)線程會(huì)共享處理器，因?yàn)橹挥袉魏?。因此在某些點(diǎn)上，一個(gè)線程會(huì)依照指令執(zhí)行完成，但在很多情況下，操作系統(tǒng)會(huì)對(duì)線程說(shuō)：時(shí)間結(jié)束了，到后面排隊(duì)再來(lái)，然后另外一個(gè)線程開(kāi)始執(zhí)行，當(dāng)下一個(gè)線程開(kāi)始執(zhí)行時(shí)，它會(huì)從被暫停的那個(gè)位置開(kāi)始執(zhí)行。所以你猜會(huì)發(fā)生什么事，當(dāng)前線程正準(zhǔn)備執(zhí)行寄存器加1操作時(shí)，系統(tǒng)把處理器交給另外一個(gè)線程?

我真的不知道會(huì)發(fā)生什么事，可能我們?cè)跍?zhǔn)備加1時(shí)，另外一個(gè)線程進(jìn)來(lái)了，重新將 counter 值加載到寄存器等多種情況的產(chǎn)生。誰(shuí)也不知道到底發(fā)生了什么。

正確的做法

解決方案就是要求同一個(gè)時(shí)間內(nèi)只允許一個(gè)線程訪問(wèn)共享變量。這個(gè)可通過(guò) std::mutex 類來(lái)解決。當(dāng)線程進(jìn)入時(shí)，加鎖、執(zhí)行操作，然后釋放鎖。其他線程想要訪問(wèn)這個(gè)共享資源必須等待鎖釋放。

互斥(mutex) 是操作系統(tǒng)確保鎖和解鎖操作是不可分割的。這意味著線程在對(duì)互斥量進(jìn)行鎖和解鎖的操作是不會(huì)被中斷的。當(dāng)線程對(duì)互斥量進(jìn)行鎖或者解鎖時(shí)，該操作會(huì)在操作系統(tǒng)切換線程前完成。

而最好的事情是，當(dāng)你試圖對(duì)互斥量進(jìn)行加鎖操作時(shí)，其他的線程已經(jīng)鎖住了該互斥量，那你就必須等待直到其釋放。操作系統(tǒng)會(huì)跟蹤哪個(gè)線程正在等待哪個(gè)互斥量，被堵塞的線程會(huì)進(jìn)入 "blocked onm" 狀態(tài)，意味著操作系統(tǒng)不會(huì)給這個(gè)堵塞的線程任何處理器時(shí)間，直到互斥量解鎖，因此也不會(huì)浪費(fèi) CPU 的循環(huán)。如果有多個(gè)線程處于等待狀態(tài)，哪個(gè)線程最先獲得資源取決于操作系統(tǒng)本身，一般像 Windows 和 Linux 系統(tǒng)使用的是 FIFO 策略，在實(shí)時(shí)操作系統(tǒng)中則是基于優(yōu)先級(jí)的。

現(xiàn)在讓我們對(duì)上面的代碼進(jìn)行改進(jìn)：

1. #include <iostream> 
2. #include <string> 
3. #include <thread> 
4. #include <vector> 
5. #include <mutex> 
6.  
7. using std::thread; 
8. using std::vector; 
9. using std::cout; 
10. using std::endl; 
11. using std::mutex; 
12.  
13. class Incrementer 
14. { 
15. private: 
16. int counter; 
17. mutex m; 
18.  
19. public: 
20. Incrementer() : counter{0} { }; 
21.  
22. void operator()() 
23. { 
24. for(int i = 0; i < 100000; i++) 
25. { 
26. this->m.lock(); 
27. this->counter++; 
28. this->m.unlock(); 
29. } 
30. } 
31.  
32. int getCounter() const 
33. { 
34. return this->counter; 
35. }  
36. }; 
37.  
38. int main() 
39. { 
40. // Create the threads which will each do some counting 
41. vector<thread> threads; 
42.  
43. Incrementer counter; 
44.  
45. threads.push_back(thread(std::ref(counter))); 
46. threads.push_back(thread(std::ref(counter))); 
47. threads.push_back(thread(std::ref(counter))); 
48.  
49. for(auto &t : threads) 
50. { 
51. t.join(); 
52. } 
53.  
54. cout << counter.getCounter() << endl; 
55.  
56. return 0; 
57. } 

注意代碼上的變化：我們引入了 mutex 頭文件，增加了一個(gè) m 的成員，類型是 mutex，在operator()() 中我們鎖住互斥量 m 然后對(duì) counter 進(jìn)行加1操作，然后釋放互斥量。

再次執(zhí)行上述程序，結(jié)果如下：

1. [lucas@lucas-desktop src]$ ./threading_example 
2. 300000 
3. [lucas@lucas-desktop src]$ ./threading_example 
4. 300000 

這下數(shù)對(duì)了。不過(guò)在計(jì)算機(jī)科學(xué)中，沒(méi)有免費(fèi)的午餐，使用互斥量會(huì)降低程序的性能，但這總比一個(gè)錯(cuò)誤的程序要強(qiáng)吧。

防范異常

當(dāng)對(duì)變量進(jìn)行加1操作時(shí)，是可能會(huì)發(fā)生異常的，當(dāng)然在我們這個(gè)例子中發(fā)生異常的機(jī)會(huì)微乎其微，但是在一些復(fù)雜系統(tǒng)中是極有可能的。上面的代碼并不是異常安全的，當(dāng)異常發(fā)生時(shí)，程序已經(jīng)結(jié)束了，可是互斥量還是處于鎖的狀態(tài)。

為了確保互斥量在異常發(fā)生的情況下也能被解鎖，我們需要使用如下代碼：

1. for(int i = 0; i < 100000; i++) 
2. { 
3. this->m.lock(); 
4. try 
5. { 
6. this->counter++; 
7. this->m.unlock(); 
8. } 
9. catch(...) 
10. { 
11. this->m.unlock(); 
12. throw; 
13. } 
14. } 

但是，這代碼太多了，而只是為了對(duì)互斥量進(jìn)行加鎖和解鎖。沒(méi)關(guān)系，我知道你很懶，因此推薦個(gè)更簡(jiǎn)單的單行代碼解決方法，就是使用 std::lock_guard 類。這個(gè)類在創(chuàng)建時(shí)就鎖定了 mutex 對(duì)象，然后在結(jié)束時(shí)釋放。

繼續(xù)修改代碼：

1. void operator()() 
2. { 
3. for(int i = 0; i < 100000; i++) 
4. { 
5. lock_guard<mutex> lock(this->m); 
6.  
7. // The lock has been created now, and immediatly locks the mutex 
8. this->counter++; 
9.  
10. // This is the end of the for-loop scope, and the lock will be 
11. // destroyed, and in the destructor of the lock, it will 
12. // unlock the mutex 
13. } 
14. } 

上面代碼已然是異常安全了，因?yàn)楫?dāng)異常發(fā)生時(shí)，將會(huì)調(diào)用 lock 對(duì)象的析構(gòu)函數(shù)，然后自動(dòng)進(jìn)行互斥量的解鎖。

記住，請(qǐng)使用放下代碼模板來(lái)編寫(xiě)：

1. void long_function() 
2. { 
3. // some long code 
4.  
5. // Just a pair of curly braces 
6. { 
7. // Temp scope, create lock 
8. lock_guard<mutex> lock(this->m); 
9.  
10. // do some stuff 
11.  
12. // Close the scope, so the guard will unlock the mutex 
13. } 
14. }