原子引用解决ABA问题

原子引用

首先先来了解这是干什么的，是为了解决ABA问题，ABA问题又是什么问题呢？看下面解释。

ABA问题用俗话来说，也就是狸猫换太子的问题，在多个线程运行下，上一个线程执行完将值返回给主存的时候，被另外一个线程更改回了原先的数据，导致下一个线程不知道线程被更改的问题！

package com.liu.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo01 {
    //cas：compareAndSet:比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2022); //底层用的cas
        //public final boolean compareAndSet(int expect, int update)
        //如果期望的值达到了就更新，否则不更新，CAS是CPU的并发原语！

        //对于写的sql：利用乐观锁解决问题：要知道谁动了线程！
        //=======捣乱的线程=========
        System.out.println(atomicInteger.compareAndSet(2022, 2023));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2023, 2022));
        System.out.println(atomicInteger.get());

        //=======捣乱的线程=========
        System.out.println(atomicInteger.compareAndSet(2022, 6666));
        System.out.println(atomicInteger.get());
    }

}

在了解ABA问题后，我们需要了解两个锁的概念，乐观锁和悲观锁的区别！见

(36条消息) Java中关于各种锁的概念_牛牛的Java学习之旅的博客-优快云博客

利用带版本号的原子引用解决ABA问题：知道谁动了线程，修改了数据，AtomicStampedReference() 带时间戳的,对应的思想是乐观锁

避坑：

Integer使用了对象缓存机制，默认范围是-128-127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用缓存，而new一定会创建新的对象分配新的内存空间，超过这个区间的所有数据都会在堆上产生，不会复用对象

package com.liu.cas;

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

public class CASDemo02 {

    public static void main(String[] args) {
        //注意：如果泛型是包装类，注意对象的引用问题，因为是对象缓存机制，超过一定访问再new的话会新分配空间地址
        //正常在业务操作，这里引用的都是一个对象
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);

        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("a1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //下面这一段代码跟乐观锁里面的version+1版本号操作一样
            System.out.println(atomicInteger.compareAndSet(1, 2,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1));

            System.out.println("a2=>"+atomicInteger.getStamp());

            System.out.println(atomicInteger.compareAndSet(2, 1,
                    atomicInteger.getStamp(), atomicInteger.getStamp() + 1));

            System.out.println("a3=>"+atomicInteger.getStamp());
        },"a").start();

        //与乐观锁的原理相同，由于中间修改过了线程，导致正常的线程不能修改，返回false
        new Thread(()->{
            int stamp = atomicInteger.getStamp();//版本号获取
            System.out.println("b1=>"+stamp);

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

            System.out.println(atomicInteger.compareAndSet(1, 6, stamp, stamp + 1));

            System.out.println("b2=>"+atomicInteger.getStamp());
        },"b").start();
    }
}