一個測試記錄：利用分段鎖來處理併發情況下的資源競爭問題

IOT物聯網小鎮發表於2022-05-22

別人的經驗，我們的階梯！

在開發中經常遇到多個併發執行的執行緒，需要對同一個資源進行訪問，也就是發生資源競爭。

在這種場景中，一般的做法就是加鎖，通過鎖機制對臨界區進行保護，以達到資源獨佔的目的。

這篇文章主要描述的就是使用分段鎖來解決這個問題，說起來很簡單：就是把鎖的粒度降低，以達到資源獨佔、最大程度避免競爭的目的。

問題描述

週末和朋友聊天說到最近的工作，他們有個專案，需要把之前的一個微控制器程式，移植到x86平臺。

由於歷史的原因，程式碼中到處都充斥著全域性變數，你懂得：在以前的微控制器中充斥著大量的全域性變數，方便、好用啊！

在程式碼中，儘量避免使用全域性變數。壞處有：不方便模組化，函式不可重入，耦合性大。。。

由於大部分的微控制器都只有一個CPU，是真正的序列操作。

也許你會說：會發生中斷啊，這也是一種非同步操作。

沒錯，但是可以在訪問全域性變數的地方把中斷關掉，這樣就不會避免了資源競爭的情況了。

但是，移植到x86平臺之後，在多核的情況下，多個執行緒(任務)是真正的併發執行序列。

如果多個執行緒同時操作某一個全域性變數，就一定存在競爭的情況。

針對這個問題，首先想到的方案就是：分配一般互斥鎖，無論哪個執行緒想訪問全域性變數，首先獲取到鎖，然後才能操作全域性變數，操作完成之後再釋放鎖。

但是，這個方案有一個很大的問題，就是：當併發執行緒很多的情況下，程式的執行效率太低。

他們最後的解決方案是分段加鎖，也就是對全域性變數按照資料索引進行分割，每一段資料分配一把鎖。

至於每一段的資料長度是多少，這需要根據實際的業務場景進行調整，以達到最優的效能。

回來之後，我覺得這個想法非常巧妙。

這個機制看起來很簡單，但是真的能解決大問題。

於是我就寫了一段程式碼來測試一下：這種方案對程式的效能有多大的影響。

程式碼已經上傳到網盤了，文末有具體的下載地址。

測試程式碼

在測試程式碼中，定義了一個全域性變數：

volatile int test_data[DATA_TOTAL_NUM];

陣列的長度是10000(巨集定義：DATA_TOTAL_NUM)，然後建立100個執行緒來併發訪問這個全域性變數，每個執行緒訪問100000次。

然後執行3個測試用例：

測試1：不使用鎖

00個執行緒同時操作全域性變數，訪問的資料索引隨機產生，最後統計每個執行緒的平均執行時間。

不使用鎖的話，最後的結果(全域性變數中的資料內容)肯定是錯誤的，這裡僅僅是為了看一下時間消耗。

測試2：使用一把全域性鎖(大鎖)

100個執行緒使用一把鎖。

每個執行緒在操作全域性變數之前，首先要獲取到這把鎖，然後才能操作全域性變數，否則的話只能阻塞著等其它執行緒釋放鎖。

測試3：使用分段鎖

根據全域性變數的長度，分配多把鎖。

每個執行緒在訪問的時候，根據訪問的資料索引，獲取不同的鎖，這樣就降低了競爭的機率。

在這個測試場景中，全域性變數test_data的長度是10000，每100個資料分配一把鎖，那麼一共需要100把鎖。

比如，在某個時刻：

執行緒1想訪問test_data[110],

執行緒2想訪問test_data[120]，

執行緒3想訪問test_data[9900]。

首先根據每個執行緒要訪問的資料索引進行計算：這個索引對應的哪一把鎖？

計算方式：訪問索引 % 每把鎖對應的資料長度

經過計算得知：執行緒1、執行緒2就會對第二把鎖進行競爭;

而執行緒3就可以獨自獲取最後一把鎖，這樣的話執行緒3就避開了與執行緒1、執行緒2的競爭。

測試結果

$ ./a.out 
test1_naked:        average = 2876 ms 
test2_one_big_lock: average = 11233 ms 
test3_segment_lock: average = 3216 ms

從測試結果上看，分段加鎖比使用一把全域性鎖，對於程式效能的提高確實很明顯。

當然了，測試結果與不同的系統環境、業務場景有關，特別是執行緒的競爭程度、在臨界區中的執行時間等。

測試程式碼簡介

這裡貼一下程式碼的結構，文末有完整的程式碼下載連結。

測試程式碼沒有考慮跨邊界的情況。

比如：某個執行緒需要訪問190 ~ 210這些索引上的資料，這個區間正好跨越了200這個分界點。

第0把鎖：0 ~ 99;

第1把鎖：100 ~ 199;

第2把鎖：200 ~ 299;

因此，訪問190 ~ 210就需要同時獲取到第1、2把鎖。

在實際專案中需要考慮到這種跨邊界的情況，通過計算開始和結束索引，把這些鎖都獲取到才可以。

當然了，為了防止發生死鎖，需要按照順序來獲取。

#define THREAD_NUMBER           100         // 執行緒個數
#define LOOP_TIMES_EACH_THREAD  100000      // 每個執行緒中 for 迴圈的執行次數
#define DATA_TOTAL_NUM          10000       // 全域性變數的長度
#define SEGMENT_LEN             100         // 多少個資料分配一把鎖

volatile int test_data[DATA_TOTAL_NUM];     // 被競爭的全域性變數

void main(void)
{
    test1_naked();
    test2_one_big_lock();
    test3_segment_lock();

    while (1)
        sleep(3);  // 主執行緒保持執行，也可以使用getchar();
}

// 測試1：子執行緒執行的函式
void *test1_naked_function(void *arg)
{
    struct timeval tm1, tm2;
    gettimeofday(&tm1, NULL);    
    for (unsigned int i = 0; i < LOOP_TIMES_EACH_THREAD; i++)
    {
        do_some_work();             // 模擬業務操作
        unsigned int pos = rand() % DATA_TOTAL_NUM; 
        test_data[pos] = i * i;     // 隨機訪問全域性變數中的某個資料
    }
    gettimeofday(&tm2, NULL);   

    return (tm2 - tm1);
}

// 測試2：子執行緒執行的函式
void *test2_one_big_lock_function(void *arg)
{
    test2_one_big_lock_arg *data = (test2_one_big_lock_arg *)arg;
    struct timeval tm1, tm2;
    gettimeofday(&tm1, NULL);  
    for (unsigned int i = 0; i < LOOP_TIMES_EACH_THREAD; i++)
    {
        pthread_mutex_lock(&data->lock);  // 上鎖

        do_some_work();             // 模擬業務操作
        unsigned int pos = rand() % DATA_TOTAL_NUM; 
        test_data[pos] = i * i;     // 隨機訪問全域性變數中的某個資料

        pthread_mutex_unlock(&data->lock); // 解鎖
    }
    gettimeofday(&tm2, NULL);    

    return (tm2 - tm1);
}

// 測試3：子執行緒執行的函式
void *test3_segment_lock_function(void *arg)
{
    test3_segment_lock_arg *data = (test3_segment_lock_arg *)arg;
    struct timeval tm1, tm2;
    gettimeofday(&tm1, NULL); 
    for (unsigned int i = 0; i < LOOP_TIMES_EACH_THREAD; i++)
    {
        unsigned int pos = rand() % DATA_TOTAL_NUM;      // 產生隨機訪問的索引
        unsigned int lock_index = pos / SEGMENT_LEN;     // 根據索引計算需要獲取哪一把鎖

        pthread_mutex_lock(data->lock + lock_index);     // 上鎖

        do_some_work();             // 模擬業務操作
        test_data[pos] = i * i;     // 隨機訪問全域性變數中的某個資料

        pthread_mutex_unlock(data->lock + lock_index);   // 解鎖
    }
    gettimeofday(&tm2, NULL);     

    return (tm2 - tm1);
}

void test1_naked()
{
    建立 100 個執行緒，執行緒執行函式是 test1_naked_function()
    printf("test1_naked:        average = %ld ms \n", ms_total / THREAD_NUMBER);
}

void test2_one_big_lock()
{
    建立 100 個執行緒，執行緒執行函式是 test2_one_big_lock_function()，需要把鎖作為引數傳遞給子執行緒。
    printf("test2_one_big_lock: average = %ld ms \n", ms_total / THREAD_NUMBER);
}

void test3_segment_lock()
{
    根據全域性變數的長度，初始化很多把鎖。
    建立 100 個執行緒，執行緒執行函式是 test2_one_big_lock_function()，需要把鎖作為引數傳遞給子執行緒。

    printf("test3_segment_lock: average = %ld ms \n", ms_total / THREAD_NUMBER);
}

------ End ------

如果文中有什麼問題，歡迎留言、討論，謝謝！

在公眾號後臺恢復：220417，可以收到示例程式碼。

在Linux系統中可以直接編譯、執行，拿來即用。

祝您好運！