一个测试记录：利用【分段锁】来处理并发情况下的资源竞争问题

volatile int test_data[DATA_TOTAL_NUM];

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

#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);
}