CAS中的ABA问题以及解决方案

ABA问题

在没有加版本号之前，CAS会出现ABA问题：当一个值原本已经被当前线程读取到，准备通过CAS（自旋锁）将其修改的时候，突然这个时候由于网络卡顿、线程中断等一系列状况的原因，中途来了另外一个线程，将当前线程所期望的值修改成其他的值，然后又修改回来，这期间当前线程没有察觉，看了下此时的值跟预取的值相同，就直接修改了。坦白说，这种情况如果不是在很严格的场景下，其实是无关紧要的，但是如果是涉及到银行系统的资金流转问题之类的就是相当严重了。所以说，ABA问题我们还是有必要解决的，而且要很好的解决。

存在ABA问题的代码

package com.lzp.juc;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author LZP
 * @Date 2021/6/10 13:24
 * @Version 1.0
 */
public class ABA {

    static volatile AtomicInteger a = new AtomicInteger();

    public static void main(String[] args) {
        // 模拟两个线程
        /*
            第一个线程去获取a的值，然后休眠两秒（即模拟时间片用完了，为的是让另一个线程去重现ABA现象）
            一开始第二个线程需要休眠20ms，其目的是让第一个线程先将其a的值读到自己的栈空间，然后自己再
            去操作a的值
         */
        Thread main = new Thread(() -> {
            int exceptVal = a.get();
            System.out.println(Thread.currentThread().getName() + "第一次获取到的值：" + exceptVal);
            try {
                // 先休眠1s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 然后再去获取a的值
            System.out.println(Thread.currentThread().getName() + "是否修改成功：" + a.compareAndSet(exceptVal, exceptVal + 1));
        }, "主线程");

        Thread ABA = new Thread(() -> {
            // 先休眠2ms
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 自增
            a.incrementAndGet();
            System.out.println(Thread.currentThread().getName() + "increment之后的值：" + a.get());
            // 自减
            a.decrementAndGet();
            System.out.println(Thread.currentThread().getName() + "decrement之后的值：" + a.get());
        }, "制造ABA问题的线程");

        // 启动线程
        main.start();
        ABA.start();
    }
}

运行结果：

利用Java中AtomicStampedReference类解决ABA问题

package com.lzp.juc;

import java.util.concurrent.atomic.AtomicStampedReference;

/**
 * @Author LZP
 * @Date 2021/6/10 13:20
 * @Version 1.0
 *
 * CAS中的ABA问题解决
 * 这里我们不能只用值来判断了，还需要有一个版本号来标识，此时我们就可以
 * 用jdk中提供的一个类AtomicStampedReference
 *
 * 其中有一个私有的静态内部类
 *  private static class Pair<T> {
 *      final T reference;
 *      final int stamp;
 *      private Pair(T reference, int stamp) {
 *          this.reference = reference;
 *          this.stamp = stamp;
 *      }
 *      static <T> Pair<T> of(T reference, int stamp) {
 *          return new Pair<T>(reference, stamp);
 *      }
 *  }
 *
 *  AtomicStampedReference与AtomicInteger进行对比
 *      1、AtomicStampedReference类：
 *      主线程第一次获取到的值：1
 *      制造ABA问题的线程increment之后的值：2
 *      制造ABA问题的线程decrement之后的值：1
 *      主线程是否修改成功：false
 *
 *      2、AtomicInteger类：
 *      主线程第一次获取到的值：0
 *      制造ABA问题的线程increment之后的值：1
 *      制造ABA问题的线程decrement之后的值：0
 *      主线程是否修改成功：true
 */
public class CASABA {

    static volatile AtomicStampedReference<Integer> a = new AtomicStampedReference<>(1, 1);

    public static void main(String[] args) {
        // 模拟两个线程
        /*
            第一个线程去获取a的值，然后休眠1秒（即模拟时间片用完了，为的是让另一个线程去重现ABA现象）
            一开始第二个线程需要休眠2ms，其目的是让第一个线程先将其a的值读到自己的栈空间，然后自己再
            去操作a的值
         */
        Thread main = new Thread(() -> {
            int exceptRef = a.getReference();
            int exceptStamp = a.getStamp();
            System.out.println(Thread.currentThread().getName() + "第一次获取到的值：" + exceptRef);
            try {
                // 先休眠1s
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 然后再去获取a的值
            System.out.println(Thread.currentThread().getName() + "是否修改成功：" + a.compareAndSet(exceptRef, exceptRef + 1, exceptStamp, exceptStamp + 1));
            System.out.println("版本号Stamp:" + a.getStamp());
        }, "主线程");

        Thread ABA = new Thread(() -> {
            // 先休眠2ms
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 自增
            a.compareAndSet(a.getReference(), a.getReference() + 1, a.getStamp(), a.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "increment之后的值：" + a.getReference());
            // 自减
            a.compareAndSet(a.getReference(), a.getReference() - 1, a.getStamp(), a.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "decrement之后的值：" + a.getReference());
        }, "制造ABA问题的线程");

        // 启动线程
        main.start();
        ABA.start();
    }

}

运行结果：