Coin163

首页 > Java之CAS操作

Java之CAS操作

相关标签: java cas

2020腾讯云8月秒杀活动,优惠非常大!(领取2860元代金券),
地址https://cloud.tencent.com/act/cps/redirect?redirect=1040

2020阿里云最低价产品入口,含代金券(新老用户有优惠),
入口地址https://www.aliyun.com/minisite/goods

相关推荐:CAS原子操作实现无锁及性能分析

http://blog.csdn.net/chen19870707/article/details/41083183 CAS原子操作实现无锁及性能分析   Author:Echo Chen(陈斌) Email:chenb19870707@gmail.com Blog:Blog.csdn.net/chen19870707 Date:Nov 13th, 2014 最近在研究nginx的自旋锁的时候,又见到

CAS操作

CAS是单词compare and set的缩写,意思是指在set之前先比较该值有没有变化,只有在没变的情况下才对其赋值。

我们常常做这样的操作

[java]  view plain copy print ?
  1. if(a==b) {  
  2.     a++;  
  3. }  
试想一下如果在做a++之前a的值被改变了怎么办?a++还执行吗?出现该问题的原因是在多线程环境下,a的值处于一种不定的状态。采用锁可以解决此类问题,但CAS也可以解决,而且可以不加锁。

[java]  view plain copy print ?
  1. int expect = a;  
  2. if(a.compareAndSet(expect,a+1)) {  
  3.     doSomeThing1();  
  4. } else {  
  5.     doSomeThing2();  
  6. }  
这样如果a的值被改变了a++就不会被执行。

按照上面的写法,a!=expect之后,a++就不会被执行,如果我们还是想执行a++操作怎么办,没关系,可以采用while循环

[java]  view plain copy print ?
  1. while(true) {  
  2.     int expect = a;  
  3.     if (a.compareAndSet(expect, a + 1)) {  
  4.         doSomeThing1();  
  5.         return;  
  6.     } else {  
  7.         doSomeThing2();  
  8.     }  
  9. }  

采用上面的写法,在没有锁的情况下实现了a++操作,这实际上是一种非阻塞算法。


应用

java.util.concurrent.atomic包中几乎大部分类都采用了CAS操作,以AtomicInteger为例,看看它几个主要方法的实现:

相关推荐:非阻塞同步机制与CAS操作

锁的劣势     Java在JDK1.5之前都是靠synchronized关键字保证同步的,这种通过使用一致的锁定协议来协调对共享状态的访问,可以确保无论哪个线程 持有守护变量的锁,都采用独占的方式来访问这些变量,如果出现多个线程同时访问锁,那第一些线线程将被挂起,当

[java]  view plain copy print ?
  1. public final int getAndSet(int newValue) {  
  2.     for (;;) {  
  3.         int current = get();  
  4.         if (compareAndSet(current, newValue))  
  5.             return current;  
  6.     }  
  7. }  
getAndSet方法JDK文档中的解释是:以原子方式设置为给定值,并返回旧值。原子方式体现在何处,就体现在compareAndSet上,看看compareAndSet是如何实现的: [java]  view plain copy print ?
  1. public final boolean compareAndSet(int expect, int update) {  
  2.     return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
  3. }  
不出所料,它就是采用的Unsafe类的CAS操作完成的。
 

 再来看看a++操作是如何实现的: 
[java]  
view plain 
copy 
print 
? 
  1. public final int getAndIncrement() {  
  2.     for (;;) {  
  3.         int current = get();  
  4.         int next = current + 1;  
  5.         if (compareAndSet(current, next))  
  6.             return current;  
  7.     }  
  8. }  
几乎和最开始的实例一模一样,也是采用CAS操作来实现自增操作的。
 ++a操作和a++操作类似,只不过返回结果不同罢了 
[java]  
view plain 
copy 
print 
? 
  1. public final int incrementAndGet() {  
  2.     for (;;) {  
  3.         int current = get();  
  4.         int next = current + 1;  
  5.         if (compareAndSet(current, next))  
  6.             return next;  
  7.     }  
  8. }  

此外,java.util.concurrent.ConcurrentLinkedQueue类全是采用的非阻塞算法,里面没有使用任何锁,全是基于CAS操作实现的。CAS操作可以说是JAVA并发框架的基础,整个框架的设计都是基于CAS操作的。


缺点:

1、ABA问题

CAS操作容易导致ABA问题,也就是在做a++之间,a可能被多个线程修改过了,只不过回到了最初的值,这时CAS会认为a的值没有变。a在外面逛了一圈回来,你能保证它没有做任何坏事,不能!!也许它讨闲,把b的值减了一下,把c的值加了一下等等,更有甚者如果a是一个对象,这个对象有可能是新创建出来的,a是一个引用呢情况又如何,所以这里面还是存在着很多问题的,解决ABA问题的方法有很多,可以考虑增加一个修改计数,只有修改计数不变的且a值不变的情况下才做a++,也可以考虑引入版本号,当版本号相同时才做a++操作等,这和事务原子性处理有点类似!

2、比较花费CPU资源,即使没有任何争用也会做一些无用功。

3、会增加程序测试的复杂度,稍不注意就会出现问题。


总结:

可以用CAS在无锁的情况下实现原子操作,但要明确应用场合,非常简单的操作且又不想引入锁可以考虑使用CAS操作,当想要非阻塞地完成某一操作也可以考虑CAS。不推荐在复杂操作中引入CAS,会使程序可读性变差,且难以测试,同时会出现ABA问题。

原文

CAS操作 CAS是单词compare and set的缩写,意思是指在set之前先比较该值有没有变化,只有在没变的情况下才对其赋值。 我们常常做这样的操作 [java]  view plain copy print if(a==b) {       

------分隔线----------------------------