谈谈你对CAS的理解以及如何处理ABA问题

1、理解CAS

什么是CAS？
大厂你必须要深入研究底层！有所突破！修内功，操作系统，计算机网络原理

package com.jialidun.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS   compareAndSet:比较并交换!
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        //int expect期望、 int update更新
        //public final boolean compareAndSet(int expect, int update) {
        //如果我期望的值达到了，name就更新，否则就不更新,CAS是CPU的并发原语！
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();//++

        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类



CAS：比较当前工作内存中的值和主内存的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
CAS：三个值，期望值，比较值，更新的值
缺点：
1、因为底层实现自旋锁，循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题
CAS：ABA问题（狸猫换太子）

package com.jialidun.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS   compareAndSet:比较并交换!
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        

        //int expect期望、 int update更新
        //public final boolean compareAndSet(int expect, int update) {
        //如果我期望的值达到了，name就更新，否则就不更新,CAS是CPU的并发原语！
        //================捣乱的线程=======================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        //=================期望的线程====================
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }
}

2、原子引用

解决ABA问题，引入原子引用！对应的思想：乐观锁！
带版本号的原子操作！
大概解释一下乐观锁：乐观锁是一种锁类型，CAS是乐观锁的一种具体实现方法，乐观锁大概也就是加个版本控制，如果事务改变那么版本也会改变！

package com.jialidun.cas;

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

public class CASDemo {

    //CAS   compareAndSet:比较并交换!
    // AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引入问题
    public static void main(String[] args) {

        //正常在业务操作，这里面比较的都是一个个对象
        AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("a1=>"+stamp);
            atomicStampedReference.compareAndSet(1,2,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
            System.out.println("a2=>"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(2,1,atomicStampedReference.getStamp(), atomicStampedReference.getStamp()+1);
            System.out.println("a3=>"+atomicStampedReference.getStamp());

        },"a").start();

        //乐观锁的原理相同！
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println("b1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicStampedReference.compareAndSet(1,6,stamp,stamp+1);
            System.out.println("b2=>"+atomicStampedReference.getStamp());

        },"b").start();

    }
}

注意：
Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间；