JUC多线程及高并发9-----ABA

男娘i 2023-06-19 05:29 23阅读 0赞

# 面试笔记 #

**CAS-----》UNsafe------》CAS底层思想--------》ABA-------》原子引用更新--------------》如何规避ABA问题**

CAS 会导致“ABA问题”

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

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two有将V位置的数据变成A，这时线程one进行CAS操作发现内存中仍是A，然后线程one操作成功。

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

ABA也可以理解为狸猫换太子，中途调换，但是结果没变

怎么解决ABA问题？

package CAS;
    
    import lombok.AllArgsConstructor;
    import lombok.Getter;
    import lombok.ToString;
    
    import java.util.concurrent.atomic.AtomicReference;
    
    @Getter
    @ToString
    class User{
       String userName;
       int age;
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }
    }
    public class AtomicReferenceDemo {
        public static void main(String[] args) {
    
            User z3=new User("z3",22);
            User li4=new User("li4",26);
            //1.用原子引用包装类
           AtomicReference<User> atomicReference = new AtomicReference<>();
            atomicReference.set(z3);
    
            System.out.println(atomicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());
            System.out.println(atomicReference.compareAndSet(z3, li4)+"\t"+atomicReference.get().toString());
    
    
        }
    }

结果

true	User{userName='li4', age=26}
    false	User{userName='li4', age=26}
    
    Process finished with exit code 0

用原子引用解决  
举例：

package CAS;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    
    public class ABADemo   //ABA问题的解决      AtomicStampedReference
    {
        //定义static变量-----普通的原子引用
        static AtomicReference<Integer>atomicReference =new AtomicReference<>(100);
        public static void main(String[] args) {
    new Thread(() -> {
        atomicReference.compareAndSet(100,101);
        atomicReference.compareAndSet(101,100);
            },"t1").start();
    
    new Thread(()->{
        //暂停1秒钟t2线程，保证上面的t1线程完成了一次ABA操作
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(atomicReference.compareAndSet(100, 2019)+"\t"+atomicReference.get());
    },"t2").start();
    
    
        }
    }

结果

true	2019
    
    Process finished with exit code 0

解决ABA问题

首先理解原子引用，加上新增一种机制，那就是修改版本号（类似时间戳）

时间戳原子引用  
AtomicStampedReference

举例：

package CAS;
    
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.concurrent.atomic.AtomicStampedReference;
    
    public class ABADemo   //ABA问题的解决      AtomicStampedReference
    {
        //定义static变量-----普通的原子引用
        static AtomicReference<Integer>atomicReference =new AtomicReference<>(100);
    //    加入版本号
        static AtomicStampedReference<Integer>atomicStampedReference =new AtomicStampedReference<>(100,1);
        public static void main(String[] args) {
    new Thread(() -> {
        atomicReference.compareAndSet(100,101);
        atomicReference.compareAndSet(101,100);
            },"t1").start();
    
    new Thread(()->{
        //暂停1秒钟t2线程，保证上面的t1线程完成了一次ABA操作
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(atomicReference.compareAndSet(100, 2019)+"\t"+atomicReference.get());
    },"t2").start();
    //俩秒钟后演示t3
            try {
                TimeUnit.SECONDS.sleep(2);
            }catch (InterruptedException e){e.printStackTrace();}
    System.out.println("============以下是ABA问题解决=============");
    
            new Thread(()->{
    int stamp =atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName()+"\t第一次版本号" +stamp);
                //暂停1秒t3
                try {
                    TimeUnit.SECONDS.sleep(1);
                }catch (InterruptedException e){e.printStackTrace();}
                atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println(Thread.currentThread().getName()+"\t第二次版本号："+stamp);
                atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println(Thread.currentThread().getName()+"\t第三次版本号："+stamp);
            },"t3").start();
            new Thread(()->{
                int stamp =atomicStampedReference.getStamp();
                System.out.println(Thread.currentThread().getName()+"\t第一次版本号" +stamp);
                //暂停3秒t4,保证上面t3完成了一次ABA
                try {
                    TimeUnit.SECONDS.sleep(3);
                }catch (InterruptedException e){e.printStackTrace();}
                boolean result =atomicStampedReference.compareAndSet(100,2019,stamp,stamp+1);
                System.out.println(Thread.currentThread().getName()+"\t修改成功否："+result+"\t当前最新实际版本号："+atomicStampedReference.getStamp());
                System.out.println(Thread.currentThread().getName()+"\t当前最新值：)"+atomicStampedReference.getReference());
            },"t4").start();
        }
    }

结果

true	2019
    ============以下是ABA问题解决=============
    t3	第一次版本号1
    t4	第一次版本号1
    t3	第二次版本号：1
    t3	第三次版本号：1
    t4	修改成功否：false	当前最新实际版本号：3
    t4	当前最新值：)100
    
    Process finished with exit code 0