是什么

全称compare and swap，一个CPU原子指令，在硬件层面实现的机制，体现了乐观锁的思想。

JVM用C语言封装了汇编调用。Java的基础库中有很多类就是基于JNI调用C接口实现了多线程同步更新的功能。

原理

CMS有三个操作数：当前主内存变量的值V，线程本地变量预期值A，线程本地待更新值B。当需要更新变量值的时候，会先获取到内存变量值V然后很预期值A进行比较，如果相同则更新为B，如果不同，则将最新的变量值更新到预期值中再重新尝试上面的步骤，直到成功为止。

举例

以基于CAS实现的AtomicInteger 类进行讲解。

我们先写一个多线程，对同一个数据类进行分别进行加减操作10000次，正确的结果应该还是0。

没有任何多线程同步机制的代码如下：

packagepriv.nanjing.testCasClass;/** @Author : darrenqiao

**/

//多线程争用的数据类

classCounter {int count = 0;public intgetCount() {returncount;

}public void setCount(intcount) {this.count =count;

}public voidadd() {

count+= 1;

}public voiddec() {

count-= 1;

}

}//争用数据做加操作的线程

class AddDataThread extendsThread {

Counter counter;publicAddDataThread(Counter counter) {this.counter =counter;

}

@Overridepublic voidrun() {for (int i = 0; i < CasClass.LOOP; ++i) {

counter.add();

}

}

}//争用数据做减法操作的线程

class DecDataThread extendsThread {

Counter counter;publicDecDataThread(Counter counter) {this.counter =counter;

}

@Overridepublic voidrun() {for (int j = 0; j < CasClass.LOOP; j++) {

counter.dec();

}

}

}public classCasClass {final static int LOOP = 10000;public static void main(String[] args) throwsInterruptedException {

Counter counter= newCounter();

Thread addThread= newAddDataThread(counter);

Thread decThread= newDecDataThread(counter);

addThread.start();

decThread.start();

addThread.join();

decThread.join();

System.out.println(counter.getCount());

}

}

以下是三次执行结果，每一次都不一样。

为什么会出现这个结果呢？

因为 count += 1 / count -= 1 通过javap反编译Count.class文件，可以看出对应的字节码是三条指令

//count += 1

5: iconst_16: iadd7: putfield #12 //Field count:I//count 1= 1

5: iconst_16: isub7: putfield #12 //Field count:I

所以多线程切换是，可能会造成数据更新的不同步，怎么解决呢？

就是对被操作的数据加锁，可以是悲观锁，可以是乐观锁，这里使用的就是基于乐观锁实现的AtomicInteger类

packagepriv.nanjing.testCasClass;importjava.util.concurrent.atomic.AtomicInteger;/** @Author : darrenqiao

**/

//多线程争用的数据类

classCounter {//int count = 0;//使用AtomicInteger代替基本数据类型

AtomicInteger count = new AtomicInteger(0);public intgetCount() {//return count;

returncount.get();

}public voidadd() {//count += 1;

count.addAndGet(1);

}public voiddec() {//count -= 1;

count.decrementAndGet();

}

}//争用数据做加操作的线程

class AddDataThread extendsThread {

Counter counter;publicAddDataThread(Counter counter) {this.counter =counter;

}

@Overridepublic voidrun() {for (int i = 0; i < CasClass.LOOP; ++i) {

counter.add();

}

}

}//争用数据做减法操作的线程

class DecDataThread extendsThread {

Counter counter;publicDecDataThread(Counter counter) {this.counter =counter;

}

@Overridepublic voidrun() {for (int j = 0; j < CasClass.LOOP; j++) {

counter.dec();

}

}

}public classCasClass {final static int LOOP = 10000;public static void main(String[] args) throwsInterruptedException {

Counter counter= newCounter();

Thread addThread= newAddDataThread(counter);

Thread decThread= newDecDataThread(counter);

addThread.start();

decThread.start();

addThread.join();

decThread.join();

System.out.println(counter.getCount());

}

}

执行多次，会发现，结果只有一个：0.这样就保证了数据更新的原子性。

那么CAS有什么缺点需要注意？

ABA问题：我内存对象从A变成B在变成A，CAS会当成没有变化，进而去更新值，实际是有变化的。

循环时间开销大：一直和预期值不对的情况下，会一直循环。

只能保证一个共享变量的原子操作。