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

最新推荐文章于 2024-03-20 17:51:29 发布

阿兵云原生

最新推荐文章于 2024-03-20 17:51:29 发布

阅读量3.3k

点赞数 1

分类专栏：后端 C语言文章标签： c语言 java 开发语言

本文链接：https://blog.csdn.net/m0_37322399/article/details/128592386

版权

后端同时被 2 个专栏收录

71 篇文章 2 订阅

订阅专栏

C语言

1 篇文章 0 订阅

订阅专栏

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