Java并发编程系列番外篇C A S(Compare and swap)
,文章风格依然是图文并茂,通俗易懂,让读者们也能与面试官疯狂对线。C A S(Compare and swap)
,文章风格依然是图文并茂,通俗易懂,让读者们也能与面试官疯狂对线。
C A S
作为并发编程必不可少的基础知识,面试时C A S
也是个高频考点,所以说C A S
是必知必会,本文将带读者们深入理解C A S
C A S
作为并发编程必不可少的基础知识,面试时C A S
也是个高频考点,所以说C A S
是必知必会,本文将带读者们深入理解C A S
。🎜C A S(compareAndSwap)
也叫比较交换,是一种无锁原子算法,映射到操作系统就是一条cmpxchg
硬件汇编指令(保证原子性),其作用是让C P U
将内存值更新为新值,但是有个条件,内存值必须与期望值相同,并且C A S
操作无需用户态与内核态切换,直接在用户态对内存进行读写操作(意味着不会阻塞/线程上下文切换)。
它包含3个参数<code style="font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color : rgba(27, 31, 35, 0.05);font-family: " operator mono consolas monaco menlo monospace break-all rgb> C A S(V,E,N)
,V
表示待更新的内存值,E
表示预期值,N
表示新值,当 V
值相等E
值时,将会V
值更新成N
值,如果V
值和E
值不等,不做更新,这就是一次C A S
的操作。3
个参数C A S(V,E,N)
,V
表示待更新的内存值,E
表示预期值,N
表示新值,当 V
值等于E
值时,才会将V
值更新成N
值,如果V
值和E
值不等,不做更新,这就是一次C A S
的操作。
简单说,C A S
C A S
需要你另外给出一个期望值,那么你认为这个变量现在应该调用的,如果变量不是你想象的那样,说明它已经被别人修改过了,你只需要重新读取,设置新的期望值,再次尝试修改就好了。🎜原子性是指一个或者多个操作在C P U
执行的过程中不被中断的特性,要么执行,要不执行,不能执行到一半(不可被中断的一个或一系列操作)。C P U
执行的过程中不被中断的特性,要么执行,要不执行,不能执行到一半(不可被中断的一个或一系列操作)。
为了保证C A S
的原子性,C P U
提供了下面两种方式
总线(B U S
)是计算机组件间的传输数据方式,也就是说C P U
与其他组件连接传输数据,就是靠总线完成的,比如C P U
C A S
的原子性,C P U
提供了下面两种方式🎜B U S
)是计算机组件间的传输数据方式,也就是说C P U
与其他组件连接传输数据,就是靠总线完成的,比如C P U
对内存的读写。🎜家居锁定是指CPU
使用了家居锁,所谓家居锁就是使用CPU
提供的LOCK#
信号,当CPU
在楼梯上输出LOCK#
信号时,其他C P U
的请求请求将被阻塞。C P U
使用了总线锁,所谓总线锁就是使用C P U
提供的LOCK#
信号,当C P U
在总线上输出LOCK#
信号时,其他C P U
的总线请求将被阻塞。
总线锁定方式虽然保证了原子性,但是在锁定期间,会导致大量阻塞,增加系统的性能开销,所以现代C P U
为了提升性能,通过锁定范围缩小的思想设计出了缓存行锁定(缓存行是C P U
C P U
为了提升性能,通过锁定范围缩小的思想设计了一个定位队列行(🎜队列行是 style="font-size: 14px;overflow-wrap: Break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: Break-all;color: rgb(255, 100, 65);">CPU
高速缓存存储的最小单位🎜)。🎜所谓缓存锁定是指C P U
对C P U
对缓存行进行锁定,当缓存行中的共享变量回写到内存时,其他C P U
会通过总线嗅探机制感知该共享变量是否发生变化,如果发生变化,让自己对应的共享变量缓存行失效,重新从内存读取最新的数据,缓存锁定是基于缓存一致性机制来实现的,因为缓存一致性机制会阻止两个以上C P U
同时修改同一个共享变量(现代C P U
基本都支持和使用缓存锁定机制)。
C A S
和锁都解决了原子性问题,和锁相比没有阻塞、线程上下文你切换、死锁,所以C A S
要比锁拥有更优越的性能,但是C A S
同样存在缺点。
C A S
缓存行
C P U
会通过总线嗅探机制感知该共享变量是否发生变化,如果发生变化,让自己对应的共享变量缓存行失效,重新从内存读取最新的数据,缓存锁定是基于缓存一致性机制来实现的,因为缓存一致性机制会阻止两个以上C P U
同时修改同一个共享变量(🎜现代C P U
基本都支持和使用缓存锁定机制🎜)。🎜C A S
和锁都解决了原子性问题,和锁相比没有阻塞、线程上下文你切换、死锁,所以C A S
要比锁拥有更优越的性能,但是C A S
同样存在缺点。🎜🎜C A S
的问题如下🎜ABA
问题ABA
问题C A S
只能针对一个共享变量使用,如果多个共享变量就只能使用锁了,当然如果你有办法把多个变量整成一个变量,利用C A S
也不错,例如读写锁中state
C A S
只能针对一个共享变量使用,如果多个共享变量就只能使用锁了,当然如果你有办法把多个变量整成一个变量,利用C A S
也不错,例如读写锁中state
的高低位。🎜
当一个线程获取锁时失败,不进行阻塞挂起,而是间隔一段时间再次尝试获取,直到成功为止,这种循环获取的机制被称为自旋锁(spinlock
)。spinlock
)。
自旋锁好处是,持有锁的线程在短时间内释放锁,那些等待竞争锁的线程就不需进入阻塞状态(无需线程上下文切换/无需用户态与内核态切换),它们只需要等一等(自旋),等到持有锁的线程释放锁之后即可获取,这样就避免了用户态和内核态的切换消耗。
自旋锁坏处显而易见,线程在长时间内持有锁,等待竞争锁的线程一直自旋,即CPU一直空转,资源浪费在毫无意义的地方,所以一般会限制自旋次数。
最后来说自旋锁的实现,实现自旋锁可以基于C A S
实现,先定义lockValue
对象默认值1
,1
代表锁资源空闲,0
C A S
实现,先定义lockValue
对象默认值1
,1
代表锁资源空闲,0
代表锁资源被占用,代码如下🎜public class SpinLock { //lockValue 默认值1 private AtomicInteger lockValue = new AtomicInteger(1); //自旋获取锁 public void lock(){ // 循环检测尝试获取锁 while (!tryLock()){ // 空转 } } //获取锁 public boolean tryLock(){ // 期望值1,更新值0,更新成功返回true,更新失败返回false return lockValue.compareAndSet(1,0); } //释放锁 public void unLock(){ if(!lockValue.compareAndSet(1,0)){ throw new RuntimeException("释放锁失败"); } } }
上面定义了AtomicInteger
类型的lockValue
变量,AtomicInteger
是Java
基于C A S
实现的Integer
原子操作类,还定义了3个函数lock、tryLock、unLock
tryLock函数-获取锁
C A S
更新C A S
更新lockValue
值相等,则lockValue
值更新为0
,返回true
,否则执行下面逻辑lockValue
值不相等,不做任何更新,返回false
如果期望值与lockValue
值足够,则lockValue
值更新为0
,返回 true
,否则执行下面逻辑
lockValue
值不够,不做任何更新,返回false
🎜🎜🎜🎜🎜unLock函数-释放锁🎜0
,更新值1
0
,更新值1
C A S
更新lockValue
值相等,则lockValue
值更新为1
,返回true
,否则执行下面逻辑lockValue
值不相等,不做任何更新,返回false
C A S
更新
lockValue
值足够,则lockValue
值更新为1
,返回true,否则执行下面逻辑🎜🎜🎜🎜 🎜🎜如果期望值与lockValue
值不够,不做任何更新,返回false🎜🎜🎜🎜🎜lock函数-自旋获取锁🎜<ul class="list-paddingleft-2" data-tool="mdnice编辑器" style="margin-top: 8px;margin-bottom: 8px;padding-left: 25px;list-style-type: square;"><li><section style="margin-top: 5px;margin-bottom: 5px;line-height: 26px;color: rgb(1, 1, 1);"><strong style="color: black;">执行<code style='overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, 0.05);font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;color: rgb(255, 100, 65);'>tryLock
函数,返回true
停止,否则一直循环从上图可以看出,只有tryLock
成功的线程(把lockValue
更新为0
),才会执行代码块,其他线程个tryLock
自旋等待lockValue
被更新成1
,tryLock
成功的线程执行unLock
(把lockValue
更新为1
),自旋的线程才会tryLock
成功。
C A S
需要检查待更新的内存值有没有被修改,如果没有则更新,但是存在这样一种情况,如果一个值原来是A
,变成了B
,然后又变成了A
,在C A S
检查的时候会发现没有被修改。
假设有两个线程,线程1
读取到内存值A
,线程1
时间片用完,切换到线程2
,线程2
也读取到了内存值A
,并把它修改为B
值,然后再把B
值还原到A
值,简单说,修改次序是A->B->A
,接着线程1
恢复运行,它发现内存值还是A
,然后执行C A S
操作,这就是著名的ABA
问题,但是好像又看不出什么问题。
只是简单的数据结构,确实不会有什么问题,如果是复杂的数据结构可能就会有问题了(使用AtomicReference
可以把C A S
使用在对象上),以链表数据结构为例,两个线程通过C A S
去删除头节点,假设现在链表有A->B
节点
1
删除A
节点,B
节点成为头节点,正要执行C A S(A,A,B)
时,时间片用完,切换到线程 2
1
删除A
节点,B
节点成为头节点,正要执行C A S(A,A,B)
时,时间片用完,切换到线程2
2
删除A、B
节点2
加入C、A
节点,链表节点变成A->C
1
重新获取时间片,执行C A S(A,A,B)
C
2
删除A、B
节点🎜🎜🎜🎜线程2
加入C、A
节点,链表节点变成A->C代码>🎜🎜🎜🎜线程1
重新获取时间片,执行C A S(A, A,B)
🎜🎜🎜🎜丢失C
节点🎜🎜
要解决A B A
问题也非常简单,只要追加版本号即可,每次改变时加1
,即A —> B —> A
,变成1A —> 2B —> 3A
,在Java
中提供了AtomicStampedRdference
可以实现这个方案(面试只要问了C A S
,就一定会问ABA
,这块一定要搞明白)。
以上是小白也能与BAT面试官对线:CAS的详细内容。更多信息请关注PHP中文网其他相关文章!