CAS原理

**CAS (campare and swap)算法与**AtomicInteger 的实现原理

• 原理：

  • CAS有三个操作数：内存值V，预期值A，更新值B

  • 如果V==A, 则V被赋值为B

  • 否则不干任何事（或循环，直到上述判断成立）

public class AtomicInteger extends Number implements java.io.Serializable {  

    private volatile int value;              //用volatile来实现可见性


    public final int get() {  
        return value;  
    }  

    public final int getAndIncrement() {  
        for (;;) {  
            int current = get();              //获取当前值
            int next = current + 1;           //加1
            if (compareAndSet(current, next)) //比较这此期间，值有没有被篡改过，如果有则重新来过
                return current;               //成功了，则返回+1以后的值
        }  
    }  

    public final boolean compareAndSet(int expect, int update) {  
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);  
    }

compareAndSet利用JNI来完成CPU指令的操作。

int compare_and_swap (int* reg, int oldval, int newval) 
{
  ATOMIC();
  int old_reg_val = *reg;
  if (old_reg_val == oldval) 
     *reg = newval;
  END_ATOMIC();
  return old_reg_val;
}

Java8中CAS的增强

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
}

1. ABA问题

• 因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。

• 从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

2. 循环时间长开销大

自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

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

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

解决ABA问题

AtomicStampedReference{
    //比较并设置
    public boolean compareAndSet(V expectedRef, V newRef, int expectedStamp, int newStamp);
    //获取当前对象引用
    public V getReference();
    //获取当前时间戳
    public int getStamp();
    //设置当前对象引用和时间戳
    public void set(V newReference,int newStammp);
}

public class Test {

    static AtomicStampedReference<Integer> money =
            new AtomicStampedReference<>(19,0);

    public static void main(String...args){

        for (int i = 0;i < 3;i++){
            final int timestamp = money.getStamp();
            new Thread(() -> {
                while (true){
                    while (true){
                        Integer m = money.getReference();
                        if (m < 20){
                            if (money.compareAndSet(m,m+20,timestamp,timestamp+1)){
                                System.out.println("充值成功，余额"+money.getReference());
                                try {
                                    Thread.sleep(500);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                break;
                            }
                        }else {
                            System.out.println("无需充值");
                            try {
                                Thread.sleep(500);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            break;
                        }
                    }
                }

            }).start();


        }

        new Thread(() -> {
            for (int j = 0;j < 100;j++){
                while (true){
                    int timestam = money.getStamp();
                    Integer m = money.getReference();
                    if (m > 10){
                        System.out.println("大于10元");
                        if (money.compareAndSet(m,m-10,timestam,timestam+1)){
                            System.out.println("消费10元，余额"+money.getStamp());
                            break;
                        }
                    }else {
                        System.out.println("余额不足");
                        break;
                    }
                }
                try {
                    Thread.sleep(500);
                }catch (InterruptedException e){}
            }
        }).start();
    }
}

---

原子类总结

• Unsafe：所有原子类都使用的东西，封装一堆native方法
• AtomicInteger
• AtomicReference: 安全地修改对象引用
• AtomicStampedReference: 解决ABA问题的AtomicReference
• AtomicIntegerArray: 数组的原子操作
• AtomicIntegerFieldUpdater
• AtomicReferenceFieldUpdater: 使得普通对象变得线程安全，而无需修改对象出现的所有地方。
  
  • 不能反射获取private变量
  • 必须是volatile类型
  • 不能是static字段

public class Test {

    public static class Candidate{
        int id;
        volatile int score;
    }

    public final static AtomicIntegerFieldUpdater<Candidate> updater
            = AtomicIntegerFieldUpdater.newUpdater(Candidate.class,"score");

    public static AtomicInteger allScore = new AtomicInteger(0);

    public static void main(String...args) throws InterruptedException {
        final Candidate stu = new Candidate();
        ExecutorService service = Executors.newFixedThreadPool(1000);
        for (int i = 0;i < 10000;i++){
            if(Math.random() > 0.4){
                service.execute(()->{
                    updater.incrementAndGet(stu);
                    allScore.incrementAndGet();
                });
            }
        }
        service.shutdown();
        service.awaitTermination(5, TimeUnit.SECONDS);
        System.out.println("score="+stu.score);
        System.out.println("allScore"+allScore);
        //输出的值是一样的，可见是原子操作
    }
}

---

乐观锁与悲观锁

• 乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库如果提供类似于write_condition机制的其实都是提供的乐观锁。

• CAS便是乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

• CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

• 悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

• 比如说synchronized就是一种独占锁，他假设最坏的情况，并且只有在确保其它线程不会造成干扰的情况下执行，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。

• 缺点： 　　由于在进程挂起和恢复执行过程中存在着很大的开销。当一个线程正在等待锁时，它不能做任何事。举个栗子，如果一个线程需要某个资源，但是这个资源的占用时间很短，当线程第一次抢占这个资源时，可能这个资源被占用，如果此时挂起这个线程，可能立刻就发现资源可用，然后又需要花费很长的时间重新抢占锁，时间代价就会非常的高。