【面试专栏】ABA问题

文章同步更新在个人公众号“梓莘”，欢迎大家关注，相互交流。

由上一篇CAS问题我们知道其容易导致ABA问题，这篇我们来学习一下相关的内容。

一、CAS为什么会导致ABA问题

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

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

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

二、原子引用

要想解决这个问题我们需要先来了解一下原子引用。

放码过来

package com.zishen;

import java.util.concurrent.atomic.AtomicReference;

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;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }

    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }
}
/**
 * @ClassName AtomicReferenceDemo
 * @Description TODO
 * @Author zishen
 * @Date 2019/12/25 19:40
 * @Version 1.0
 **/
public class AtomicReferenceDemo {

    public static void main(String[] args) {
        AtomicReference atomicReference = new AtomicReference();
        User u1 = new User("u1",11);
        User u2= new User("u2",22);
        atomicReference.set(u1);

        System.out.println(atomicReference.compareAndSet(u1,u2)+"\t"+atomicReference.get().toString());

    }
}

AtomicReference的作用是对“对象”进行原子操作，提供了一种读和写都是原子性的对象引用变量。也就意味着多个线程在改变同一个AtomicReference将不会使其处于不一致的状态。
其实AtomicReference与AtomicInteger非常类似，不同之处在于AtomicInteger是对整型的封装，而AtomicReference对应的是对象的引用。

三、解决方案

juc包中提供了AtomicStampedReference来解决ABA问题。可类比数据库中的乐观锁。

放码过来

package com.zishen;

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

/**
 * @ClassName ABADemo
 * @Description 时间戳的原子引用
 * @Author zishen
 * @Date 2019/12/25 19:50
 * @Version 1.0
 **/
public class ABADemo {

    static AtomicReference atomicReference = new AtomicReference<>(10);

    static AtomicStampedReference atomicStampedReference = new AtomicStampedReference<>(10,1);
    public static void main(String[] args) {
        System.out.println("以下是ABA问题的产生");
        new Thread(()->{
            atomicReference.compareAndSet(10,11);
            atomicReference.compareAndSet(11,10);
        },"t").start();
        new Thread(()->{
            try {
                //为了保证t现在完成了一次ABA操作
                TimeUnit.SECONDS.sleep(1);
                atomicReference.compareAndSet(10,12);
                System.out.println(atomicReference.get());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t1").start();

        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 第一次版本号"+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(1);
                atomicStampedReference.compareAndSet(10,11,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println(Thread.currentThread().getName()+"\t 第二次版本号"+atomicStampedReference.getStamp());
                atomicStampedReference.compareAndSet(11,10,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
                System.out.println(Thread.currentThread().getName()+"\t 第三次版本号"+atomicStampedReference.getStamp());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t2").start();

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName()+"\t 第一次版本号"+stamp);
            try {
                //暂停t3保证t2完成一次ABA问题
                TimeUnit.SECONDS.sleep(3);
                boolean result = atomicStampedReference.compareAndSet(10,2019,stamp,stamp+1);
                System.out.println(Thread.currentThread().getName()+" 修改"+result);
                System.out.println(Thread.currentThread().getName()+" 当前最新版本号"+atomicStampedReference.getStamp());
                System.out.println(Thread.currentThread().getName()+" 当前最新值"+atomicStampedReference.getReference());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"t3").start();
    }
}

书写不易，转载请注明出处。