共计 3272 个字符，预计需要花费 9 分钟才能阅读完成。
明天不整 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;
}
后果
通过上述后果，咱们能够看到，加互斥锁，自旋锁，原子操作，数据都能如我所愿的累加正确，在工夫下面他们还是有肯定的差别：
自旋锁 和 互斥锁 在此处的案例性能差不多，然而原子操作绝对就快了很多
欢送点赞，关注，珍藏
敌人们，你的反对和激励，是我保持分享，提高质量的能源
好了，本次就到这里
技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。
我是 阿兵云原生，欢送点赞关注珍藏，下次见~
正文完
