Java多线程中的CAS操作

多线程的CAS操作

CAS的全称是Compare-And-Swap，比较并交换，是一条CPU并发原语

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

CAS并发原语体现在Java语言中就是sum.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用于范畴，是由若干指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被打断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题

AtomicInteger atomicInteger = new AtomicInteger(5);
//compareAndSet（eexpect，update）：如果期望值和内存中真实的值一样，则修改为update的值
//如果一样，那么就不修改
System.out.println(atomicInteger.compareAndSet(5, 2019) +" : "+ atomicInteger.get());
atomicInteger.getAndIncrement();

atomicInteger.getAndIncrement()的源码

public final int getAndIncrement() {
    //调用unsafe的方法
    //this：当前对象
    //valueOffset：内存偏移量，内存地址
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

unsafe.getAndAddInt()的源码

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        //var1：对应一开始的this
        //var2：对应valueOffset，内存偏移地址
        //获取当前对象的值，相当于拷贝值到自己的工作内存
        var5 = this.getIntVolatile(var1, var2);
        //当前对象对应地址上的值与取得的值比较，相同则交换
        //如果不同，就循环获取最新的值，进行比较，直到执行操作为止
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

1.Unsafe

是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过native方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe存在sun.misc包下，其内部方法可以像C的指针一样直接操作内存,因为Java中CAS操作的执行依赖与Unsafe类的方法。

Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中所有的方法都可以直接调用操作系统底层资源执行相应任务

2.valueOffset

表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

3.value

变量value使用volatile修饰的，保证了多线程之间的内存可见性

CAS的缺点

1. 循环时间长开销很大
   • 如果CAS失败，会一直进行尝试。如果长时间不成功，可能会给CPU带来很大的开销
2. 只能保证一个共享变量的原子操作
   • 对多个共享变量操作时，循环CAS就无法保证操作的原子性，这时候需要用到锁
3. 引出ABA问题

ABA问题

CAS算法实现的一个重要前提是需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差内会导致数据的变化。

比如：一个线程one从内存中取出A，这时候two线程也从内存中取出A，并且把A替换成了B，然后线程two又把B改回了A，这时候one线程进行CAS操作发现内存中A的值没有变动，然后CAS操作执行成功。

尽管线程one的CAS操作是成功的，但是不代表过程没有问题

原子引用

除了有普通类型的原子类，还可以有自己定义的原子类，AtomicReference泛型传入需要的类

User user1 = new User("张三",18);
User user2 = new User("李四",23);

AtomicReference<User> atomicReference = new AtomicReference<>();
atomicReference.set(user1);

//直接用atomicReference相当于User有了原子性
System.out.println(atomicReference.compareAndSet(user1, user2) + " : " +
	atomicReference.get().toString()); //true
System.out.println(atomicReference.compareAndSet(user1, user2) + " : " +
	atomicReference.get().toString()); //false

class User{

    String username;
    int age;
 	
    //get/set/constructor/toString
}

解决ABA问题

可以给字段加一个版本号或时间戳，这时候会用到另一个原子引用类：AtomicStampedReference

package com.ctgu.juc;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CAS {

    public static void main(String[] args) {
        
        /**
         * ABA问题的演示
         */
        AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
        new Thread(()->{
            //t1线程第一次修改为101
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicReference.compareAndSet(100,101)+" "+atomicReference.get());
            //t1线程第二次修改回100
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicReference.compareAndSet(101,100)+" "+atomicReference.get());
        },"t1").start();
        new Thread(()->{
            try{
                //t2线程先休眠1s保证t1线程执行完
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            //t2线程CAS操作：只要是100就修改为2019，但是不知道中间修改过一次
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicReference.compareAndSet(100,2019)+" "+atomicReference.get());
        },"t2").start();
        /**
         * ABA问题用时间戳（版本号）解决
         * AtomicStampedReferenced
         */
         //初始值，初始版本号
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100,1);
        new Thread(()->{
            //获得最开始的版本号为1
            int stamp = atomicStampedReference.getStamp();
            try{
                Thread.sleep(2000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            //t3线程修改值为101，版本号+1，现在版本号为2
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),
            	atomicStampedReference.getStamp()+1)+" "+atomicStampedReference.getStamp());
            //t3线程修改值回100，版本号+1，现在版本号为3
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),
            	atomicStampedReference.getStamp()+1)+" "+atomicStampedReference.getStamp());
        },"t3").start();
        new Thread(()->{
            //获取最初的版本号为1
            int stamp = atomicStampedReference.getStamp();
            try{
                Thread.sleep(4000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            //不会修改成功，因为版本号不匹配
            System.out.println(Thread.currentThread().getName()+" : "+
            	atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1)+" "+
           		atomicStampedReference.getStamp());
        },"t4").start();

    }

}