深入Phtread(二)：線程的同步-Mutex

原創 madaoheng 2020-02-22 21:31
並行的世界，沒有同步，就失去了秩序，就會亂作一團！試想，交通沒有紅綠燈，生產線產品裝配沒有一定的順序... 結果是顯而易見的。多個線程也需要同步，否則程序運行起來結果不可預測，這是我們最不能容忍的。交通的同步機制就是紅綠燈，Pthread提供了互斥量（mutex）和條件變量（Condition Variables）兩種機制去同步線程。
  1. 不變量，臨界區和判定條件
  2. 互斥量（Mutex）
  3. 創建和銷燬互斥量
  4. 鎖定和解鎖
  5. 調整mutex大小
  6. 使用多個mutex
  7. 鎖定鏈

不變量，臨界區和判定條件

    不變量（Invariant）：程序所做的一些假設，特別是指變量之間的關係。如：一個queue，有頭節點，和其它數據節點，這些元素之間的連接關係就是不變量。當程序裏面不變量遭受破壞時，後果往往是很嚴重的，輕則數據出錯，重則程序直接崩潰。

    臨界區（Critical Section）：處理共享數據的一段代碼。
    
    判定條件（Predicates）：描述不變量狀態的邏輯表達式。

互斥量（Mutex）

    一般，多個線程之間都會共享一些數據，當多個線程同時訪問操作這些共享數據時。問題出來了，一個線程正在修改數據時，另外一個可能也去操作這些數據，結果就會變得不一致了。如(gv=0是共享的數據)：
   
     線程A：a = gv; gv = a + 10; 
     線程B: b = gv; gv = a + 100;
    可能發生A執行完a=gv(0)時，B開始執行b=gv(0); gv=a+100，此時gv=100，然後a執行gv=a+10，最後gv=10。並不是我們要的結果，我們的想法是兩個線程併發的給gv加上一個值，期望結果110。^_^ 若這是你銀行卡的餘額，若沒有同步，那就慘了（你往卡里打錢，你有個朋友也同時往你卡里匯錢，很有可能餘額只僅加上一方打的）。

    互斥量就是爲了解決這種問題而設計的，它是Dijkstra信號量的一種特殊形式。它使得線程可以互斥地訪問共享數據。如：

 


    
    上圖展示了三個線程共享一個互斥量，位於矩形中心線下方的線程鎖定了該互斥量；位於中心線上方且在矩形範圍內的線程等待該互斥量被解鎖，出於阻塞狀態，在矩形外面的線程正常運行。剛開始，mutex是解鎖的，線程1成功將其鎖定，據爲己有，因爲並沒有其它線程擁有它。然後，線程2嘗試去鎖定，發現被線程1佔用，所以阻塞於此，等到線程1解鎖了該mutex，線程2立馬將mutex鎖定。過了會，線程3嘗試去鎖定mutex，由於mutex被鎖定，所以阻塞於此。線程1調用pthread_mutex_trylock嘗試去鎖定個mutex，發現該mutex被鎖定，自己返回繼續執行，並沒有阻塞。繼續線程2解鎖，線程3鎖定成功，最後線程3完成任務解鎖mutex。

創建和銷燬互斥量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int pthread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t* attr);
int pthread_mutex_destroy(pthread_mutex_t* mutex);

不要嘗試去使用複製的的mutex，結果未定義。

靜態創建，當mutex以extern或者static存儲時，可以用PTHREAD_MUTEX_INITIALIZER初始化，此時該mutex使用默認屬性。
[cpp] view plaincopy
  1. #include "error.h"  
  2. #include <pthread.h>  
  3.   
  4. typedef struct my_struct_tag  
  5. {  
  6.     pthread_mutex_t mutex;  
  7.     int value;  
  8. } my_struct_t;  
  9.   
  10. my_struct_t data = { PTHREAD_MUTEX_INITIALIZER, 0};  
  11.   
  12. int main()  
  13. {  
  14.     return 0;  
  15. }  
    
動態創建，往往使用mutex時，都會將它和共享數據綁在一起，此時就需要pthread_mutex_init去動態初始化了，記得用完後pthread_mutex_destroy。
[cpp] view plaincopy
  1. #include "error.h"  
  2. #include <pthread.h>  
  3.   
  4. typedef struct my_struct_tag  
  5. {  
  6.     pthread_mutex_t mutex;  
  7.     int value;  
  8. } my_struct_t;  
  9.   
  10. int main()  
  11. {  
  12.     my_struct_t* data;  
  13.     int status;  
  14.   
  15.     data = (my_struct_t*)malloc(sizeof(my_struct_t));  
  16.     status = pthread_mutex_init(&data->mutex, NULL);  
  17.     if(status != 0)  
  18.         ERROR_ABORT(status, "pthread_mutex_init");  
  19.   
  20.     pthread_mutex_destroy(&data->mutex);  
  21.     free(data);  
  22.   
  23.     return 0;  
  24. }  
 

鎖定和解鎖

原則見上面。
int pthread_mutex_lock(pthread_mutex_t* mutex);
int pthread_mutex_trylock(pthread_mutex_t* mutex);
int pthread_mutex_unlock(pthread_mutex_t* mutex);
[cpp] view plaincopy
  1. #include <pthread.h>  
  2. #include <sys/types.h>  
  3. #include "error.h"  
  4. #include <errno.h>  
  5.   
  6. #define SPIN 10000000  
  7.   
  8. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;  
  9. long counter;  
  10. time_t end_time;  
  11.   
  12. void* counter_thread(void* arg)  
  13. {  
  14.     int status;  
  15.     int spin;  
  16.   
  17.     while(time(NULL) < end_time)  
  18.     {  
  19.         status = pthread_mutex_lock(&mutex);  
  20.         if(status != 0)  
  21.             ERROR_ABORT(status, "Lock mutex");  
  22.   
  23.         for(spin = 0; spin < SPIN; spin++)  
  24.             counter++;  
  25.   
  26.         status = pthread_mutex_unlock(&mutex);  
  27.         if(status != 0)  
  28.             ERROR_ABORT(status, "Unlock mutex");  
  29.         sleep(1);  
  30.     }  
  31.   
  32.     printf("Coutner is %#lx/n", counter);  
  33.   
  34.     return NULL;  
  35. }  
  36.   
  37. void* monitor_thread(void* arg)  
  38. {  
  39.     int status;  
  40.     int misses = 0;  
  41.   
  42.     while(time(NULL) < end_time)  
  43.     {  
  44.         sleep(3);  
  45.   
  46.         status = pthread_mutex_trylock(&mutex);  
  47.         if(status != EBUSY)  
  48.         {  
  49.             if(status != 0)  
  50.                 ERROR_ABORT(status, "Trylock mutex");  
  51.               
  52.             printf("Counter is %ld/n", counter/SPIN);  
  53.             status = pthread_mutex_unlock(&mutex);  
  54.             if(status != 0)  
  55.                 ERROR_ABORT(status, "Unlock mutex");  
  56.         }else  
  57.             misses++;  
  58.     }  
  59.     printf("Monitro thread missed update %d times./n", misses);  
  60.     return NULL;  
  61. }  
  62.   
  63. int main()  
  64. {  
  65.     int status;  
  66.     pthread_t pid_counter;  
  67.     pthread_t pid_monitor;  
  68.   
  69.     end_time = time(NULL) + 60;  
  70.   
  71.     status = pthread_create(&pid_counter, NULL, counter_thread, NULL);  
  72.     if(status != 0)  
  73.         ERROR_ABORT(status, "fail to create thread counter");  
  74.   
  75.     status = pthread_create(&pid_monitor, NULL, monitor_thread, NULL);  
  76.     if(status != 0)  
  77.         ERROR_ABORT(status, "fail to create monitor thread");  
  78.   
  79.     status = pthread_join(pid_counter, NULL);  
  80.     if(status != 0 )  
  81.         ERROR_ABORT(status, "fail to join counter thread");  
  82.   
  83.     status = pthread_join(pid_monitor, NULL);  
  84.     if(status != 0)  
  85.         ERROR_ABORT(status, "fail to join monitor thread");  
  86.   
  87.     return 0;  
  88. }  

調整mutex大小

    mutex應該多大？這裏的大小是相對的，如mutex鎖定到解鎖之間的代碼只有一行，比起有10行的就小了。 原則是：儘可能大，但不要太大（As big as neccessary, but no bigger）。考慮下面的因素：1> mutex並不是免費的，是有開銷的，不要太小了，太小了程序只忙於鎖定和解鎖了。2> mutex鎖定的區域是線性執行的，若太大了，沒有發揮出併發的優越性。
3> 自己掂量1和2，根據實際情況定，或者嘗試着去做。

使用多個mutex

使用多個mutex一定要注意，防止死鎖（deadlock）發生。下面是一個典型死鎖：
線程A：pthread_mutex_lock(&mutex_a); pthread_mutex_lock(&mutex_b); ...
線程B：pthread_mutex_lock(&mutex_b); pthread_mutex_lock(&mutex_a); ...

存在這種可能，線程A執行了第一句，鎖定了mutex_a；然後線程開始執行第一句鎖定mutex_b；然後他們互相等待解鎖mutex，A等mutex_b被解鎖，B等mutex_a被解鎖，不肯讓步，出於死鎖狀態。
[cpp] view plaincopy
  1. #include <pthread.h>  
  2. #include "error.h"  
  3. #include <time.h>  
  4.   
  5. pthread_mutex_t mutex_a = PTHREAD_MUTEX_INITIALIZER;  
  6. pthread_mutex_t mutex_b = PTHREAD_MUTEX_INITIALIZER;  
  7.   
  8. void* thread1(void* arg)  
  9. {  
  10.     while(1)  
  11.     {  
  12.         /*sleep(1);*/  
  13.         pthread_mutex_lock(&mutex_a);  
  14.         pthread_mutex_lock(&mutex_b);  
  15.   
  16.         printf("[%lu]thread 1 is running! /n", time(NULL));  
  17.   
  18.         pthread_mutex_unlock(&mutex_b);  
  19.         pthread_mutex_unlock(&mutex_a);  
  20.     }  
  21.     return NULL;  
  22. }  
  23.   
  24. void* thread2(void* arg)  
  25. {  
  26.     while(1)  
  27.     {  
  28.         /*sleep(1);*/  
  29.   
  30.         pthread_mutex_lock(&mutex_b);  
  31.         pthread_mutex_lock(&mutex_a);  
  32.   
  33.         printf("[%lu]thread 2 is running! /n",time(NULL));  
  34.   
  35.         pthread_mutex_unlock(&mutex_a);  
  36.         pthread_mutex_unlock(&mutex_b);  
  37.   
  38.     }  
  39.     return NULL;  
  40. }  
  41.   
  42. int main()  
  43. {  
  44.     pthread_t tid1, tid2;  
  45.     int status;  
  46.   
  47.     status = pthread_create(&tid1, NULL, thread1, NULL);  
  48.     if(status != 0)  
  49.         ERROR_ABORT(status, "thread 1");  
  50.   
  51.     status = pthread_create(&tid2, NULL, thread2, NULL);  
  52.     if(status !=0)  
  53.         ERROR_ABORT(status, "thread 2");  
  54.   
  55.     status = pthread_join(tid1, NULL);  
  56.     if(status != 0)  
  57.         ERROR_ABORT(status, "join thread1");  
  58.   
  59.     status = pthread_join(tid2, NULL);  
  60.     if(status != 0)  
  61.         ERROR_ABORT(status, "join thread2");  
  62. }  


解決死鎖的方法：
固定鎖定順序（Fixed locking hierarchy）：鎖定mutex的順序固定。
線程A：pthread_mutex_lock(&mutex_a); pthread_mutex_lock(&mutex_b); ...
線程B：pthread_mutex_lock(&mutex_a); pthread_mutex_lock(&mutex_b); ...

嘗試和回退（Try and back off）： 鎖定第一個後，嘗試鎖定下一個，若鎖定成功，繼續嘗試下一個，若鎖定失敗，解鎖先去鎖定的。

解鎖順序不會引起死鎖.
[cpp] view plaincopy
  1. #include <pthread.h>  
  2. #include "error.h"  
  3. #include <errno.h>  
  4.   
  5. #define ITERATIONS 100  
  6.   
  7.   
  8. pthread_mutex_t mutex[3] = {  
  9.     PTHREAD_MUTEX_INITIALIZER,  
  10.     PTHREAD_MUTEX_INITIALIZER,  
  11.     PTHREAD_MUTEX_INITIALIZER  
  12. };  
  13.   
  14. int backoff = 1;  
  15. int yield_flag = 0;  
  16.   
  17. void* lock_forward(void* arg)  
  18. {  
  19.     int i, iterate, backoffs;  
  20.     int status;  
  21.   
  22.     for(iterate = 0; iterate < ITERATIONS; iterate++)  
  23.     {  
  24.         backoffs = 0;  
  25.         for(i = 0; i < 3; i++){  
  26.             if(i == 0)  
  27.             {  
  28.                 status = pthread_mutex_lock(&mutex[i]);  
  29.                 if(status != 0)  
  30.                     ERROR_ABORT(status,"Lock mutex");  
  31.             }else  
  32.             {  
  33.                 if(backoff)  
  34.                     status = pthread_mutex_trylock(&mutex[i]);  
  35.                 else  
  36.                     status = pthread_mutex_lock(&mutex[i]);  
  37.   
  38.                 if(status == EBUSY)  
  39.                 {  
  40.                     backoff++;  
  41.                     printf("forward locker backing off at %d./n", i);  
  42.                     for(; i >= 0; i--)  
  43.                     {  
  44.                         status = pthread_mutex_unlock(&mutex[i]);  
  45.                         if(status != 0)  
  46.                             ERROR_ABORT(status, "Unlock mutex");  
  47.                     }  
  48.                 }else  
  49.                 {  
  50.                     if(status != 0)  
  51.                         ERROR_ABORT(status, "Lock mutex");  
  52.                       
  53.                     printf("forward locker got %d /n", i);  
  54.                 }  
  55.             }  
  56.   
  57.             if(yield_flag){  
  58.                 if(yield_flag > 0)  
  59.                     sched_yield();  
  60.                 else  
  61.                     sleep(1);  
  62.             }  
  63.         }  
  64.   
  65.         printf("lock forward got all locks , %d backoffs/n", backoffs);  
  66.   
  67.         pthread_mutex_unlock(&mutex[2]);  
  68.         pthread_mutex_unlock(&mutex[1]);  
  69.         pthread_mutex_unlock(&mutex[0]);  
  70.         sched_yield();  
  71.     }  
  72.   
  73.     return NULL;  
  74. }  
  75.   
  76. void* lock_backward(void* arg)  
  77. {  
  78.     int i, iterate, backoffs;  
  79.     int status;  
  80.   
  81.     for(iterate = 0; iterate < ITERATIONS; iterate++)  
  82.     {  
  83.         backoffs = 0;  
  84.         for(i = 2; i >= 0; i--){  
  85.             if(i == 2)  
  86.             {  
  87.                 status = pthread_mutex_lock(&mutex[i]);  
  88.                 if(status != 0)  
  89.                     ERROR_ABORT(status,"Lock mutex");  
  90.             }else  
  91.             {  
  92.                 if(backoff)  
  93.                     status = pthread_mutex_trylock(&mutex[i]);  
  94.                 else  
  95.                     status = pthread_mutex_lock(&mutex[i]);  
  96.   
  97.                 if(status == EBUSY)  
  98.                 {  
  99.                     backoff++;  
  100.                     printf("backward locker backing off at %d./n", i);  
  101.                     for(; i < 3; i++)  
  102.                     {  
  103.                         status = pthread_mutex_unlock(&mutex[i]);  
  104.                         if(status != 0)  
  105.                             ERROR_ABORT(status, "Unlock mutex");  
  106.                     }  
  107.                 }else  
  108.                 {  
  109.                     if(status != 0)  
  110.                         ERROR_ABORT(status, "Lock mutex");  
  111.                       
  112.                     printf("backward locker got %d /n", i);  
  113.                 }  
  114.             }  
  115.   
  116.             if(yield_flag){  
  117.                 if(yield_flag > 0)  
  118.                     sched_yield();  
  119.                 else  
  120.                     sleep(1);  
  121.             }  
  122.         }  
  123.   
  124.         printf("lock backward got all locks , %d backoffs/n", backoffs);  
  125.   
  126.         pthread_mutex_unlock(&mutex[0]);  
  127.         pthread_mutex_unlock(&mutex[1]);  
  128.         pthread_mutex_unlock(&mutex[2]);  
  129.         sched_yield();  
  130.     }  
  131.   
  132.   
  133.     return NULL;  
  134. }  
  135.   
  136. int main(int argc, char* argv[])  
  137. {  
  138.     pthread_t forward, backward;  
  139.     int status;  
  140.   
  141.     if(argc > 1)  
  142.         backoff = atoi(argv[1]);  
  143.   
  144.     if(argc > 2)  
  145.         yield_flag = atoi(argv[2]);  
  146.   
  147.     status = pthread_create(&forward, NULL, lock_forward, NULL);  
  148.     if(status != 0)  
  149.         ERROR_ABORT(status, "Create forward");  
  150.   
  151.     status = pthread_create(&backward, NULL, lock_backward, NULL);  
  152.     if(status != 0)  
  153.         ERROR_ABORT(status, "Create backward");  
  154.   
  155.     pthread_exit(NULL);  
  156. }  

鎖定鏈

 
一般用於遍歷數據結果（樹，鏈表），一個用於鎖定指針，一個鎖定數據。
形如：
pthread_mutex_lock(&mutex_a); 
pthread_mutex_lock(&mutex_b); 
...
pthread_mutex_unlock(&mutex_a)
...
pthread_mutex_unlock(&mutex_b)

注意，鎖定鏈往往會出現大量的鎖定和解鎖操作，有時會得不償失。
站內首發文章
madaoheng
發佈了8 篇原創文章 · 獲贊 5 · 訪問量 3萬+
私信 關注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

POSIX 多線程程序設計

madaoheng 2020-02-22 21:31:15

深入Phtread(三)：線程的同步-Condition Variables

madaoheng 2020-02-22 21:31:15

深入Phtread(一)：線程的一生

madaoheng 2020-02-22 21:31:15

深入Pthread(四)：一次初始化-pthread_once_t

madaoheng 2018-09-01 12:46:06

深入Pthread(五)：線程屬性

madaoheng 2018-09-01 12:45:59

Linux線程技術的概念與技術發展

madaoheng 2018-09-01 12:45:59