(java并发)CAS操作原理以及Atomic的原理

CAS操作可以分为以下三个步骤：

步骤 1.读旧值(即从系统内存中读取所要使用的变量的值，例如：读取变量i的值)

步骤2.求新值（即对从内存中读取的值进行操作，但是操作后不修改内存中变量的值，例如：i=i+1,这一步只进行 i+1,没有赋值，不对内存中的i进行修改）

步骤3.两个不可分割的原子操作


第一步：比较内存中变量现在的值与 最开始读的旧值是否相同(即从内存中重新读取i的值，与一开始读取的 i进行比较)

第二步：如果这两个值相同的话，则将求得的新值写入内存中（即：i=i+1,更改内存中的i的值）

如果这两个值不相同的话，则重复步骤1开始

注：这两个操作是不可分割的原子操作，必须两个同时完成

CAS操作

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

我们常常做这样的操作

[java] view
plaincopyprint?

if(a==b) {

a++;

}

试想一下如果在做a++之前a的值被改变了怎么办？a++还执行吗？出现该问题的原因是在多线程环境下，a的值处于一种不定的状态。采用锁可以解决此类问题，但CAS也可以解决，而且可以不加锁。

[java] view
plaincopyprint?

int expect = a;

if(a.compareAndSet(expect,a+1)) {

doSomeThing1();

} else {

doSomeThing2();

}

这样如果a的值被改变了a++就不会被执行。

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

[java] view
plaincopyprint?

while(true) {

int expect = a;

if (a.compareAndSet(expect, a + 1)) {

doSomeThing1();

return;

} else {

doSomeThing2();

}

}

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

应用

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

[java] view
plaincopyprint?

public final int getAndSet(int newValue) {

for (;;) {

int current = get();

if (compareAndSet(current, newValue))

return current;

}

}

getAndSet方法JDK文档中的解释是：以原子方式设置为给定值，并返回旧值。原子方式体现在何处，就体现在compareAndSet上，看看compareAndSet是如何实现的：

[java] view
plaincopyprint?

public final boolean compareAndSet(int expect, int update) {

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

不出所料，它就是采用的Unsafe类的CAS操作完成的。

再来看看a++操作是如何实现的：

[java] view
plaincopyprint?

public final int getAndIncrement() {

for (;;) {

int current = get();

int next = current + 1;

if (compareAndSet(current, next))

return current;

}

}

几乎和最开始的实例一模一样，也是采用CAS操作来实现自增操作的。

++a操作和a++操作类似，只不过返回结果不同罢了

[java] view
plaincopyprint?

public final int incrementAndGet() {

for (;;) {

int current = get();

int next = current + 1;

if (compareAndSet(current, next))

return next;

}

}

此外，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问题。