C 语言的 互斥锁、自旋锁、原子操作

今天不整 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;
}


结果

通过上述结果,我们可以看到,加互斥锁,自旋锁,原子操作,数据都能如我所愿的累加正确,在时间上面他们还是有一定的差异:

自旋锁 和 互斥锁 在此处的案例性能差不多,但是原子操作相对就快了很多

欢迎点赞,关注,收藏

朋友们,你的支持和鼓励,是我坚持分享,提高质量的动力

好了,本次就到这里

技术是开放的,我们的心态,更应是开放的。拥抱变化,向阳而生,努力向前行。

我是阿兵云原生,欢迎点赞关注收藏,下次见~

本作品采用《CC 协议》,转载必须注明作者和本文链接
关注微信公众号:阿兵云原生
讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!