C 語言的 互斥鎖、自旋鎖、原子操作

阿兵雲原生發表於2023-01-11

今天不整 GO 語言，我們來分享一下以前寫的 C 程式碼，來看看 互斥鎖，自旋鎖和原子操作的 demo

互斥鎖

臨界區資源已經被1個執行緒佔用，另一個執行緒過來訪問臨界資源的時候，會被CPU切換執行緒，不讓執行後來的這個執行緒

適用於 鎖住的內容多，（例如紅黑數的增加節點操作），切換執行緒的代價小於等待的代價

自旋鎖

臨界區資源已經被1個執行緒佔用，另一個執行緒過來訪問臨界資源的時候，相當於是一個 while(1)

不斷的檢視這個資源是否可用，如果可用，就進去訪問臨界資源，如果不可用，則繼續迴圈訪問

適用於鎖住的內容少，（例如就執行++操作），切換執行緒的代價大於等待的代價

原子操作

執行的操作完全不可分割，要麼全部成功，要麼全部失敗

最好的方式就是適用原子操作

實操

需求場景：

1、用10個執行緒分別對 count 加 100000 次， 看看結果是否是 10*100000

  • main 函式中建立 10 個執行緒
  • 執行緒函式中呼叫 inc 做資料的增加
  • 分別使用 互斥鎖，自旋鎖，和原子操作，來進行控制

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

#define PTHREAD_NUM    10
#define INFO    printf


pthread_mutex_t mutex;
pthread_spinlock_t spin;


int inc(int *v,int add)
{
    int old;
    //彙編，做一個原子操作
    __asm__ volatile(
        "lock;xaddl %2, %1;"
        :"=a" (old)
        :"m"(*v),"a"(add)
        :"cc","memory"
    );
    
    return old;
}

void * thread_callback(void *arg)
{
    int *count = (int *)arg;

    int i = 100000;
    
while(i--)
    {
    #if 0
//互斥鎖
        pthread_mutex_lock(&mutex);
        (*count)++;
        pthread_mutex_unlock(&mutex);
    #elif 0
//自旋鎖
        pthread_spin_lock(&spin);
        (*count)++;
        pthread_spin_unlock(&spin);
    #else
//原子操作
        inc(count,1);
    
    #endif
        usleep(1);
    }

}

int main()
{
    pthread_t thread[PTHREAD_NUM] = {0};
    pthread_mutex_init(&mutex,NULL);
    pthread_spin_init(&spin,0);
    
    int count  = 0;

    for(int i = 0;i<PTHREAD_NUM;i++){
        pthread_create(&thread[i],NULL,thread_callback,&count);
    }

    for(int i = 0;i<100;i++)
    {
        INFO("count == %d\n",count);
        sleep(1);
    }
        
    
    return 0;
}

如上程式碼還是很簡單的，感興趣的 xdm 可以自行執行，控制自己使用互斥鎖，自旋鎖或者是原子操作看看效果進行對比一下

2、mutex、lock、atomic 效能對比

思路還是和上面的思路型別，我們們可以透過下面的程式碼來實際初步看看 mutex、lock、atomic 各自的效能

//併發
//互斥鎖mutex
//    如果獲取不到資源會讓出cpu
//    使用場景
//        共享區域執行的內容較多的情況
//自旋鎖spinlock
//    如果獲取不到資源，會原地自旋，忙等
//    使用場景
//        共享區域執行的內容較少的情況
//原子操作
//    不可分割
//    使用場景
//        做簡單++、--操作
//


#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

#define MAX_PTHREAD 2
#define LOOP_LEN    1000000000
#define LOOP_ADD    10000

int count = 0;

pthread_mutex_t mutex;
pthread_spinlock_t spin;

typedef void *(*functhread)(void *arg);

void do_add(int num)
{
    int sum = 0;
    for(int i = 0;i<num;i++)
    {
        sum +=i;
    }
}

int atomic_add(int *v,int add)
{
    int old;

    __asm__ volatile(
        "lock;xaddl %2, %1;"
        :"=a" (old)
        :"m"(*v),"a"(add)
        :"cc","memory"
    );
    
    return old;
}

void * atomicthread(void *arg)
{

    for(int i  = 0;i<LOOP_LEN;i++){
        atomic_add(&count,1);
    }
}


void * spinthread(void *arg)
{
    for(int i  = 0;i<LOOP_LEN;i++){

        pthread_spin_lock(&spin);
        count++;
        //do_add(LOOP_ADD);
        pthread_spin_unlock(&spin);

    }
}

void * mutexthread(void *arg)
{
    for(int i  = 0;i<LOOP_LEN;i++){

        pthread_mutex_lock(&mutex);
        count++;

        //do_add(LOOP_ADD);
        pthread_mutex_unlock(&mutex);

    }
}

int test_lock(functhread thre,void * arg)
{

    clock_t start = clock();
    pthread_t tid[MAX_PTHREAD] = {0};

    for(int i = 0;i<MAX_PTHREAD;i++)
    {
    //建立執行緒
        int ret = pthread_create(&tid[i],NULL,thre,NULL);
        if(0 != ret)
        {
            printf("pthread create rror\n");
            return -1;
        }
    }

    for(int i = 0;i<MAX_PTHREAD;i++){
//回收執行緒
        pthread_join(tid[i],NULL);
    }

    clock_t end = clock();

    //printf("start  -- %ld\n",start);
    //printf("end  -- %ld\n",end);
    //printf("CLOCKS_PER_SEC  -- %ld\n",CLOCKS_PER_SEC);
    printf("spec lock is  -- %ld\n",(end - start)/CLOCKS_PER_SEC);

}


int main()
{
    pthread_mutex_init(&mutex,NULL);
    pthread_spin_init(&spin,0);
//測試spin
    count = 0;
    printf("use spin ------ \n");
    test_lock(spinthread,NULL);
    printf("count == %d\n",count);


//測試mutex
    count = 0;
    printf("use mutex ------ \n");
    test_lock(mutexthread,NULL);
    printf("count == %d\n",count);

//測試atomic
    count = 0;
    printf("use automic ------ \n");
    test_lock(atomicthread,NULL);
    printf("count == %d\n",count);

    return 0;
}

結果

透過上述結果，我們可以看到，加互斥鎖，自旋鎖，原子操作，資料都能如我所願的累加正確，在時間上面他們還是有一定的差異：

自旋鎖 和 互斥鎖 在此處的案例效能差不多，但是原子操作相對就快了很多

歡迎點贊，關注，收藏

朋友們，你的支援和鼓勵，是我堅持分享，提高質量的動力

好了，本次就到這裡

技術是開放的，我們的心態，更應是開放的。擁抱變化，向陽而生，努力向前行。

我是阿兵雲原生，歡迎點贊關注收藏，下次見~

相關文章