01-022【jvm】CAS与原子类ABA问题

CAS即Compare and Swap ，体现了乐观锁思想

CAS

CAS是什么？
CAS：即Compare-And-Swap，它是一条CPU并发原语，它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

获取共享变量时，为了保证该变量的可见性，需要使用volatile修饰。结合CAS和volatile可以实现无锁并发，适用于竞争不激烈、多核CPU的场景下。
底层原理
CAS并发原语体现在java语言中就是sun.misc.UnSafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致的问题。

以AtomicInteger为例，源码

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

那么UnSafe类是什么？
在rt.jar中，jdk的基础类，其中方法均由native修饰

1. 是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，UnSafe相当于一个后门，基于该类可以直接操作特定内存的数据。UnSafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于UnSafe类的方法。
   注意UnSafe类中的所有方法都是native修饰的，也就是说UnSafe类中的方法都直接调用操作系统底层资源执行相应任务
2. 上述源码中变量valueOffSet，表示该变量值在内存中的偏移地址，因为UnSafe就是根据内存偏移地址获取数据的。
3. 变量value用volatile修饰，保证了多线程的内存可见性。

CAS挺好的，有没有什么缺点呢？

1. 循环时间长，开销大，即失败会一直进行尝试，会给CPU带来很大的开销；
2. 只能保证一个共享变量的原子操作；多个共享变量必须加锁保证原子性；
3. 可能出现ABA问题

ABA问题

原子类AtomicInteger的ABA问题谈谈？原子更新引用知道吗？如何规避ABA问题？

1. ABA问题的产生
   CAS会导致ABA问题，因为CAS算法的一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差内会导致数据的变化，比如线程one从内存位置V中取出A，另一个线程two也从内存中取出A，并在two进行了一些操作将值变为B，然后two又将V位置的数据变为A，这时one进行CAS操作发现内存中仍是A，然后线程one操作成功，尽管成功，但是不代表这个过程没有问题。

2. 解决ABA问题：时间戳原子引用
   针对原子引用AtomicReference也会存在ABA问题，通过时间戳原子引用可以解决这个问题。

package com.magic.juc0117;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.ToString;

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

@Getter
@AllArgsConstructor
@ToString
class User{
    String userName;
    int age;
}

public class ABADemo {

//    public static void main(String[] args) {
//        User zs = new User("zs",23);
//        User test = new User("tt",9);
//        AtomicReference<User> atomicReference = new AtomicReference<>();
//        atomicReference.set(zs);
//        System.out.println(atomicReference.compareAndSet(zs,test)+"\t"+atomicReference.get().toString());
//        System.out.println(atomicReference.compareAndSet(zs,test)+"\t"+atomicReference.get().toString());
//    }

    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
    static AtomicStampedReference<Integer> stampedReference =new AtomicStampedReference<>(100,1);
    public static void main(String[] args) {
        System.out.println("===============以下是ABA问题的产生=======================");
        new Thread(() -> {
            atomicReference.compareAndSet(100,101);
            atomicReference.compareAndSet(101,100);
        },"t1").start();
        
        new Thread(() -> {
            try{
                TimeUnit.SECONDS.sleep(1);
         System.out.println(atomicReference.compareAndSet(100,2019)+"\t"+atomicReference.get());
            } catch (Exception e){
                throw new RuntimeException(e);
            }
        },"t2").start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("===============以下是ABA问题的解决=======================");

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第一次版本号"+stamp);
            try{
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e){
                throw new RuntimeException(e);
            }
            stampedReference.compareAndSet(100,101,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第2次版本号"+stampedReference.getStamp());

            stampedReference.compareAndSet(101,100,stampedReference.getStamp(),stampedReference.getStamp()+1);
            System.out.println(Thread.currentThread().getName()+"\t第3次版本号"+stampedReference.getStamp());

        },"t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t第1次版本号"+stamp);
            try{
                //等ts完成一次ABA
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e){
                throw new RuntimeException(e);
            }
            boolean result = stampedReference.compareAndSet(100,2019,stamp,stamp+1);
            System.out.println(Thread.currentThread().getName()+"\t"+result+"\t"+stampedReference.getStamp());
            System.out.println(Thread.currentThread().getName()+"\t当前实际最新值："+stampedReference.getReference());
        },"t4").start();
    }
}

学习整理于面试题.