十、原子操作

阿新 • • 發佈：2021-09-17

std::atomic原子操作：

互斥量：多執行緒程式設計中用於保護共享資料：先鎖住，操作共享資料，解鎖。

有兩個執行緒，對一個變數進行操作，一個執行緒讀這個變數的值，一個執行緒往這個變數中寫值。

即使是一個簡單變數的讀取和寫入操作，如果不加鎖，也有可能會導致讀寫值混亂。

一條C++語句 i++ 會被拆成3條彙編語句來執行，所以仍然有可能混亂
彙編指令：read i；inc i；store i。
a執行緒讀取 i (i=1)放入暫存器加1，變成2，同時b執行緒讀取i （i=1）放入暫存器加1，變成2，然後a，b都把2放回記憶體，但其實此時結果已經為3了。

 1 using namespace 
 std;
 2 int g_count = 0;
 3  
 4 void mythread1() {
 5     for (int i = 0; i < 1000000; i++) {
 6         g_count++;
 7     }
 8 }
 9  
10 int main() {
11     std::thread t1(mythread1);
12     std::thread t2(mythread1);
13     t1.join();
14     t2.join();
15     cout << "正常情況下結果應該是200 0000次，實際是" << g_count << endl;
 
16 }

使用mutex解決這個問題

 1 using namespace std;
 2 int g_count = 0;
 3 std::mutex mymutex;
 4  
 5 void mythread1() {
 6     for (int i = 0; i < 1000000; i++) {
 7         std::unique_lock<std::mutex> u1(mymutex);
 8         g_count++;
 9     }
10 }
11  
12  
13 int main() {
14     std::thread t1(mythread1);
15     std::thread t2(mythread1);
16     t1.join();
17     t2.join();
18     cout << "正常情況下結果應該是200 0000次，實際是" << g_count << endl;
19 }

大家可以把原子操作理解成一種：不需要用到互斥量加鎖（無鎖）計數多執行緒併發變成方式，加鎖後會很慢。

原子操作：在多執行緒中不會被打斷的程式執行片段，從效率上來說，原子操作要比互斥量的方式效率要高。

互斥量的加鎖一般是針對一個程式碼段，而原子操作針對的一般都是一個變數，而不是一個程式碼段。

原子操作，一般都是指“不可分割的操作”；也就是說這種操作狀態要麼是完成的，要麼是沒完成的，不可能出現半完成狀態。

std::atomic來代表原子操作，是個類模板。其實std::atomic使用來封裝某個型別的值

 1 using namespace std;
 2 std::atomic<int> g_count = 0; //封裝了一個型別為int的 物件（值）
 3  
 4 void mythread1() {
 5     for (int i = 0; i < 1000000; i++) {
 6         g_count++;
 7     }
 8 }
 9  
10  
11 int main() {
12     std::thread t1(mythread1);
13     std::thread t2(mythread1);
14     t1.join();
15     t2.join();
16     cout << "正常情況下結果應該是200 0000次，實際是" << g_count << endl;
17 }

修改程式碼試試：

 1 using namespace std;
 2 std::atomic<int> g_count = 0; //封裝了一個型別為int的 物件（值）
 3  
 4 void mythread1() {
 5     for (int i = 0; i < 1000000; i++) {
 6         g_count = g_count + 1; //雖然g_count使用了原子操作模板，但是這種寫法既讀又寫，
 7                                 //會導致計數錯誤
 8     }
 9 }
10  
11  
12 int main() {
13     std::thread t1(mythread1);
14     std::thread t2(mythread1);
15     t1.join();
16     t2.join();
17     cout << "正常情況下結果應該是200 0000次，實際是" << g_count << endl;
18 }