JAVA乐观锁实现-CAS

是什么

• 全称compare and swap，一个CPU原子指令，在硬件层面实现的机制，体现了乐观锁的思想。
• JVM用C语言封装了汇编调用。Java的基础库中有很多类就是基于JNI调用C接口实现了多线程同步更新的功能。

原理

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

举例

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

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

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

package priv.nanjing.testCasClass;

/*
 * @Author : darrenqiao
 * */

//多线程争用的数据类
class Counter {
    int count = 0;

    public int getCount() {
        return count;
    }

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

    public void add() {
        count += 1;
    }

    public void dec() {
        count -= 1;
    }
}

//争用数据做加操作的线程
class AddDataThread extends Thread {

    Counter counter;

    public AddDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < CasClass.LOOP; ++i) {
            counter.add();
        }
    }
}

//争用数据做减法操作的线程
class DecDataThread extends Thread {

    Counter counter;

    public DecDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int j = 0; j < CasClass.LOOP; j++) {
            counter.dec();
        }
    }
}

public class CasClass {
    final static int LOOP = 10000;

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread addThread = new AddDataThread(counter);
        Thread decThread = new DecDataThread(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_1
       6: iadd
       7: putfield      #12                 // Field count:I

     //count 1= 1
       5: iconst_1
       6: isub
       7: putfield      #12                 // Field count:I

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

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

package priv.nanjing.testCasClass;

import java.util.concurrent.atomic.AtomicInteger;

/*
 * @Author : darrenqiao
 * */

//多线程争用的数据类
class Counter {
    //int count = 0;
    //使用AtomicInteger代替基本数据类型
    AtomicInteger count = new AtomicInteger(0);

    public int getCount() {
        //return count;
        return count.get();
    }

    public void add() {
        //count += 1;
        count.addAndGet(1);
    }

    public void dec() {
        //count -= 1;
        count.decrementAndGet();
    }
}

//争用数据做加操作的线程
class AddDataThread extends Thread {

    Counter counter;

    public AddDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int i = 0; i < CasClass.LOOP; ++i) {
            counter.add();
        }
    }
}

//争用数据做减法操作的线程
class DecDataThread extends Thread {

    Counter counter;

    public DecDataThread(Counter counter) {
        this.counter = counter;
    }

    @Override
    public void run() {
        for (int j = 0; j < CasClass.LOOP; j++) {
            counter.dec();
        }
    }
}

public class CasClass {
    final static int LOOP = 10000;

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread addThread = new AddDataThread(counter);
        Thread decThread = new DecDataThread(counter);
        addThread.start();
        decThread.start();
        addThread.join();
        decThread.join();
        System.out.println(counter.getCount());
    }

}

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

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

• ABA问题：我内存对象从A变成B在变成A，CAS会当成没有变化，进而去更新值，实际是有变化的。
• 循环时间开销大：一直和预期值不对的情况下，会一直循环。
• 只能保证一个共享变量的原子操作。