锁与原子操作CAS的原理

最新推荐文章于 2022-10-01 22:42:15 发布
最新推荐文章于 2022-10-01 22:42:15 发布
阅读量411 收藏
点赞数 1
分类专栏： 进阶知识 文章标签： c语言 c++ 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42331828/article/details/123263797
版权

文章目录

一、互斥锁mutex

锁的概念
对一块临界资源加锁，临界资源在使用中只能被一个线程使用，例如厕所的坑位，只能一个人去蹲

//创建10个线程
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#define THREAD_COUNT 10

void *func(void *args) 
{
	int *pcount = (int*)args;
	int i=0;
	while(i++<100000){
      (*pcount)++;//10个线程共用的资源
      usleep(1);
	}
}
int main(){
     pthread_t thid[10]={0};
     int count = 0;
     for (int i = 0;i < THREAD_COUNT; i++) {
         pthread_create(&thid[i], null, func, &count);
         /*第一个参数是线程的id，第二个是线程的属性，第三个是入口函数，第四个是传到子线程的参数*/
     }
     for(int i=0; i < 100; i++){//每隔一秒打印一次，最后理想结果是100万
         printf("count -->%d\n",count);
        sleep(1);
     }
     return 0;
}

我们来运行一下，十个线程共有count这个资源同时加一的过程，发觉最终的值小于100万，为什么会出现这种事呢
在这里插入图片描述
我们来看看自加一的操作在汇编当中的实现，先在内存中把idx move到eax寄存器里边，再通过寄存器进行一个自增，再把idx写回到原来的内存中
在这里插入图片描述
问题出现在哪呢？比如说在下面这张图里最开始idx=20，先是线程1切换时保存了寄存器的状态，然后从线程2切换回来时，线程1里边的值还是20，线程1再执行+1操作，因此在线程1和2中都执行了+1，但是效果只是执行了一次+1，所以总共执行100万次的+1会导致最后的值小于100万

在这里插入图片描述
我们该怎么改呢，我们试试加锁，只允许一个线程运行
我们用互斥锁

//创建10个线程
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#define THREAD_COUNT 10
pthread_mutex_t mutex;
void *func(void *args) 
{
	int *pcount = (int*)args;
	int i=0;
	//外边加锁的话，其中usleep是没有必要，一定要对需要加锁的临界资源加锁，非临界资源就不用加了
	while(i++<100000){
		 pthread_mutex_lock(&mutex);
     (*pcount)++;
     pthread_mutex_unlock(&mutex);
     usleep(1);
	}
}
int main(){
     pthread_t thid[10]={0};
     int count = 0;
     pthread_mutex_init(&mutex, NULL);
     for (int i = 0;i < THREAD_COUNT; i++) {
         pthread_create(&thid[i], NULL, func, &count);
     }
     for(int i=0; i < 100; i++){//每隔一秒打印一次，最后理想结果是100万
         printf("count -->%d\n",count);
        sleep(1);
     }
     return 0;
}

实现效果
在这里插入图片描述

二、自旋锁

我们来看看自旋锁，自旋锁的使用和互斥锁是一样的

//创建10个线程
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#define THREAD_COUNT 10
//pthread_mutex_t mutex;
pthread_spinlock_t spinlock;
void *func(void *args) 
{
	int *pcount = (int*)args;
	int i=0;
	//外边加锁的话，其中usleep是没有必要，一定要对需要加锁的临界资源加锁，非临界资源就不用加了
	while(i++<100000){
		 //pthread_mutex_lock(&mutex);
		 pthread_spin_lock(&spinlock);
     (*pcount)++;
     //pthread_mutex_unlock(&mutex);
     pthread_spin_unlock(&spinlock);
     usleep(1);
	}
}
int main(){
     pthread_t thid[10]={0};
     int count = 0;
     pthread_spin_init(&spinlock, PTHREAD_PROCESS_SHARED);
     for (int i = 0;i < THREAD_COUNT; i++) {
         pthread_create(&thid[i], NULL, func, &count);
     }
     for(int i=0; i < 100; i++){//每隔一秒打印一次，最后理想结果是100万
         printf("count -->%d\n",count);
        sleep(1);
     }
     return 0;
}

区别在哪呢
mutex互斥锁当遇到锁被占用时，会引起线程切换，使用场景在于操作复杂，有系统调用
spinlock自旋锁当遇到锁被占用时会一直在锁这里停留，直到锁被让出，，使用场景在于临界资源操作简单，没有系统调用
如何去判断复杂和简单呢，这里的复杂指的是比线程切换还重的复杂

三.原子操作

cpu执行的最小单元是指令，那我们有没有办法把这三条指令变成一条指令执行呢，这里我们引入原子操作。
在这里插入图片描述

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#define THREAD_COUNT 10
//pthread_mutex_t mutex;
pthread_spinlock_t spinlock;
int inc(int *value, int add) {
	int old;
	__asm__ volatile(
		"lock; xaddl %2, %1;"|
		:"=a" (old)
		:"m" (*value), "a" (add)
		: "cc", "memory"
	);
	return old;
}
void *func(void *args) 
{
	int *pcount = (int*)args;
	int i=0;
	while(i++<100000){
		//(*pcount)++;
     inc(pcount,1);
     usleep(1);
	}
}
int main(){
     pthread_t thid[10]={0};
     int count = 0;
     pthread_spin_init(&spinlock, PTHREAD_PROCESS_SHARED);
     for (int i = 0;i < THREAD_COUNT; i++) {
         pthread_create(&thid[i], NULL, func, &count);
     }
     for(int i=0; i < 100; i++){//每隔一秒打印一次，最后理想结果是100万
         printf("count -->%d\n",count);
        sleep(1);
     }
     return 0;
}

原子操作核心需要cpu指令集支持才可以，原子操作只能在操作比较简单的情况下运用
CAS是原子操作的一种，扩写为compare and swap，
例如：cmppxchg(a,b,c);—>if(a==b) a=c;这就是CAS的一种

四、线程私有空间

解决函数内部调用时，在线程当中使用次数较多，且不能当作函数的参数传进去时，我们就需要线程的私有空间

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#define THREAD_COUNT 3
pthread_key_t key;
typedef void *(*thread_cb)(void*);
void print_tread1_key(void) {
   int *p = (int*)pthread_getspecific(key);//我们利用的key来获取这个值
   printf("thread 1:%d\n", *p);
}
void print_tread2_key(void) {
   int *ptr = (char*)pthread_getspecific(key);
   printf("thread 2:%d\n", ptr);
}
void print_tread3_key(void) {
   struct pair *p =(struct pair*)pthread_getspecific(key);
   printf("thread 2:%d, %d\n", p->x, p->y);
}
void *thread1_proc(void *args) {
	int i=5;
	pthread_setspecific(key, &i);//私有空间设在key这里
	print_tread1_key();//我们并没有把key当做参数传进去，我们线程的私有空间就是key
}
void *thread2_proc(void *args) {
	char *ptr = "thread2_proc";
	pthread_setspecific(key, ptr);
	print_tread2_key();
}
struct pair() {
	int x;
	int y;
}
void *thread3_proc(void *args) {
	struct pair p = {1,2};
	pthread_setspecific(key, &p);
	print_tread3_key();
}
int main(){
     pthread_t thid[10]={0};
     int count = 0;
     pthread_mutex_init(&mutex, NULL);
     pthread_key_create(&key, NULL);
     thread_cb_callback[THREAD_COUNT] = {//运行三个线程
     	thread1_proc,
     	thread2_proc,
     	thread3_proc
     }
     int i=0;
     for(i=0;i<THREAD_COUNT;i++){
     	ptread_create(&thid[i], NULL, callback[i], &count);
     }
     for(i=0;i<THREAD_COUNT;i++){
     	ptread_join(thid[i], NULL);
     }
     return 0;
}

我们来看下运行结果
在这里插入图片描述

五、cpu的亲缘性

让cpu做一个粘合的作用,更大地利用cpu的性能

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define __USE_GNU
#include <sched.h>
#include<unistd.h>
#include<pthread.h>
#include<setjmp.h>
#include <sys/syscall.h>
jmp__buf env;//
int count = 0;
void process_affinity(int num) {
   //gettid();
	pid_t selfid = syscall(__NR_gettid);//返回进程id
	cpu_set_t mask;//bit set
	CPU_ZERO(&mask);
	CPU_SET(selfid%num, &mask);
	//第一个参数进程id号，第二个是mask的大小，第三个参数是绑定的cpu 
	sched_setaffinity(selid, sizeof(mask), &mask);
	while(1);
}
int main(){
     int num = sysconf(_SC_NPROCESSORS_CONF);//cpu的数量
     int i = 0;
     pid_t pid = 0;
     for (i=0;i<num/2;i++) {//比如说num=8，那么我们就创建4个进程
     	pid = fork();
     	if(pid<=(pid_t)0) {
     		break;
     	}
     }
     if(pid==0) {
     	process_affinity(num);//黏合
     }
     while(1) usleep(1);
     return 0;
}

运行结果，8核的cpu，粘合之后有4个核是满的占用率100%，粘合的作用在于能够更大程度去利用CPU
在这里插入图片描述

六、setjmp/longjmp

longjmp是c++中唯一一个可以破坏栈的，执行不用出栈
setjmp一设置，运行到longjmp以后，直接跳转到setjmp这里去

//创建10个线程
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<setjmp.h>
jmp__buf env;//
int count = 0;
void sub_func(int idx) {
	printf("sub_func:%d\n",idx);
	longjmp(env, idx);//执行到这一步直接跳到setjmp(env);这一行
}
int main(){
     count = setjmp(env);//正常状态下返回0，如果有longjmp返回值由longjmp的第二个参数决定
     if(count==0) {
     	sub_func(++count);
     } else if(count==1) {
     	sub_func(++count);
     }  else if(count==2) {
     	sub_func(++count);
     } else if(count==3) {
     	sub_func(++count);
     }else {
     	printf("other items\n");
     }//从count=1开始依次往下运行
     return 0;
}

运行结果
在这里插入图片描述
这里我们就能引出try-catch是怎么做的

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<setjmp.h>
jmp__buf env;//
int count = 0;
#define Try count = setjmp(env); if(count==0)
#define Catch (type) else if(count == type)
#define Throw(type) longjmp(env, type);
#define Finally
void sub_func(int idx) {
	printf("sub_func:%d\n",idx);
	Throw(idx);
}
int main(){
     Try{
      	sub_func(++count);
     } Catch(1) {
     	sub_func(++count);
     } Catch(2) {
     	sub_func(++count);
     } Catch(3) {
     	sub_func(++count);
     } Finally{
     	printf("other items\n");
     }
     return 0;
}

但是我们引出了以下两个问题需要后续好好讨论思考一下
1、嵌套try怎么解决
我想到了用链表实现try嵌套
2、线程安全怎么解决
我想到了线程的私有空间
未完待续。。。

猥琐猿
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
原子操作CAS和显示锁
lynn1995的博客
05-30 434
1级标题
CAS原子操作实现无锁及性能分析
热门推荐
@Echo· 个人技术笔记
11-13 4万+
最近在研究nginx的自旋锁的时候，又见到了GCC CAS原子操作，于是决定动手分析下CAS实现的无锁到底性能如何，网上关于CAS实现无锁的文章很多，但少有研究这种无锁的性能提升的文章，这里就以实验结果和我自己的理解逐步展开。
锁机制与原子操作 <第四篇>
ajwqb06628的专栏
04-07 778
锁机制与原子操作 <第四篇> 一、线程同步中的一些概念 　　1.1临界区(共享区)的概念 　　在多线程的环境中，可能需要共同使用一些公共资源，这些资源可能是变量，方法逻辑段等等，这些被多个线程共用的区域统称为临界区(共享区)，临界区的资源不是很安全，...
原子操作/CAS/锁
05-31 238
（1）原子操作：单条指令 （2）多条指令原子操作（临界区）：锁（内存屏障+原子变量） （3）CAS也是一种原子操作（不同ARCH都有对应的指令实现）——CAS要知道变量的当前值的前提下才能重新设置变量的值 （4）CAS的引入可以实现无锁编程 （5）有锁编程和无锁编程的区别 a. 有锁编程：如果当前获取锁的线程被中断，其他等待锁的线程也就停下来，直到被中断的线程中断返回，继续执行释放锁后，其他线程才能继续获取锁运行； b. 无锁编程当前线程被中断不影响其他线程运行； c. 无锁编程示例：
原子操作的实现：CAS与锁
业精于勤荒于嬉 行成于思毁于随
04-30 990
首先什么是原子操作？ 原子本意是“不能被进一步分割的最小粒子”，而原子操作意为”不可被中断的一个或一系列操作”； 处理器如何实现原子操作？ 首先处理器会自动保证基本的内存操作的原子性：处理器保证从系统内存当中读取或者写入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。 总线锁保证原子性：所谓总线锁就是使用处理器提供的一个LOCK＃信号，当一个处理器...
Java原子操作CAS原理解析
08-25
Java原子操作CAS原理解析是Java并发编程中的一种机制，用于解决多线程并行情况下使用锁造成的性能损耗。CAS操作包含三个操作数——内存位置（V）、预期原值（A）、新值(B)。如果内存位置的值与预期原值相匹配，那么...
Java CAS底层实现原理实例详解
08-25
在 Java 中，CAS 操作通常用于实现原子操作，如 AtomicInteger 类。AtomicInteger 类通过使用 Unsafe 类的 compareAndSwapInt 方法来实现 CAS 操作。compareAndSwapInt 方法将内存地址的值与预期原值比较，如果相...
Java CAS原理深度分析
07-12
### Java CAS原理深度分析 #### 一、引言 在多线程编程中，原子操作是一种重要的技术，它能够确保操作的完整性和一致性，避免数据竞争。Java中的`java.util.concurrent`包提供了一系列原子类来支持高效并发操作，...
C#中使用Interlocked进行原子操作的技巧
09-01
C#中的`System.Threading.Interlocked`类提供了一系列的静态方法，用于执行线程安全的原子操作，避免了锁机制带来的开销。在本文中，我们将深入探讨`Interlocked`类的工作原理以及如何在实践中应用它。 首先，我们...
Java CAS基本实现原理代码实例解析
08-18
Java CAS（Compare And Swap，比较并交换）是 Java 中的一种并发机制，它可以实现原子性的操作。在 Java 中，CAS 是通过 java.util.concurrent.atomic 包来实现的，例如 AtomicInteger、AtomicBoolean、AtomicLong ...
原子操作CAS与锁实现
最新发布
you_fathe的博客
10-01 612
原子操作与锁实现
3.CAS操作（轻量级锁）
624回锅肉的博客
03-04 664
CAS操作相关
C++后端开发（3.2.1）—— 原子操作CAS与锁实现
weixin_43687811的博客
03-31 1648
C++后端开发（3.2.1）—— 原子操作CAS与锁实现简介 小节提纲 1.互斥锁的使用场景与原理 2.自旋锁的性能分析 3.原子操作的汇编实现
【CAS】CAS原理|乐观锁
bandaoyu的note
08-20 432
前言 CAS的原理 CAS的缺陷 1.ABA问题 2.循环时间长开销大 3.只能保证一个共享变量的原子操作 CAS开销 CAS算法在JDK中的应用 前言 这个视频解释很不错：《大厂面试题：CAS原理怎么回答比较好》 https://haokan.baidu.com/v?vid=8074278900654133189&pd=bjh&fr=bjhauthor&type=video CAS的原理 1、什么是CAS？ CAS：Compare and Swap，.
CAS 乐观锁原理
procedure_study的博客
04-18 393
由于近期面试问到锁机制，就上网找了些资料学习学习，记录下来。 synchronized是悲观锁，这种线程一旦得到锁，其他需要锁的线程就挂起的情况就是悲观锁。 CAS操作的就是乐观锁，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。 1：synchronized 加了同步锁之后，count自增的操作变成了原子性操作，所以最终的输出一定是count=200，代...
原子操作的实现原理（锁和循环CAS）
cristianoxm的博客
06-02 767
本文转自https://www.cnblogs.com/duanxz/archive/2012/08/09/2630071.html 一、引言 原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为”不可被中断的一个或一系列操作” 。在多处理器上实现原子操作就变得有点复杂。本文让我们一起来聊一聊在Inter处理器和Java里是如何实现原子操作的。 二、术语定义 三、处理器如何实现原子操作 32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理
锁机制及CAS实现原理
qq_43313035
08-07 1419
文章目录锁机制悲观锁乐观锁锁机制存在的问题两种锁总结CAS（Compare & Set/Compare & Swap）CAS算法原理描述 锁机制 常用的锁机制有两种：悲观锁、乐观锁 悲观锁 假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作。 悲观锁的实现，往往依靠底层提供的锁机制。 悲观锁会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。 乐观锁 假设不会发生并发...
加锁CAS的底层原理
qq_40276626的博客
11-02 1160
加锁的底层利用的是CPU的一个原子指令，CompareAndSwap，也就是我们说的CAS。 如何加锁呢？ 拿互斥锁为例，在一块内存中维护一个变量和线程信息，当变量为0的时候，代表当前无锁，当变量为1的时候，代表有锁，并将自己的线程信息写入，代表当前线程占用锁了。 每个想要拿到锁的线程都通过CPU的CompareAndSwap指令来获取锁，对应的指令为cas（addr，0，1），这条指令的意思是地址为adder的内存中存储的变量取值为0的时候，才将变量改为1，表示加锁成功。 1、首先来说，CPU的架构决定了
CAS，自旋锁底层原理
闻臻
12-09 1182
底层原理：自旋锁 Unsafe类调用操作系统底层资源执行任务 valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value")); 像C的指针一样直接操锁内存 unsafe.getAndAddInt(this,valueOffset,1); this:当前对象 valueOff...
Java并发编程：原子操作CAS详解
由于现代处理器在硬件层面提供了对原子操作的支持，例如通过总线锁、缓存锁以及循环CAS（CompareAndSwap）指令来保证原子性。在Java中，原子操作主要通过处理器的CMPXCHG指令实现，它结合了处理器锁和循环CAS，确保...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值