JAVA CAS-ABA的问题解决 AtomicStampedReference

待我称王封你为后i 2023-06-27 06:24 15阅读 0赞

在说AtomicStampedReference前，我们回顾一下CAS是什么？CAS 是Compare-And-Swap的简写即对比交换，它在保证数据原子性的前提下尽可能的减少了锁的使用 也就是我们经常是的乐观锁 ；目标值 期望值。

Java中实现CAS主要还是依赖unsafe类提供的底层方法，看源码我们可知其都是native 方法；所以说是原子性操作

public final native boolean compareAndSwapObject(Object value, long valueOffset, Object expect, Object update);
    
    public final native boolean compareAndSwapInt(Object value, long valueOffset, int expect, int update);
    
    public final native boolean compareAndSwapLong(Object value, long valueOffset, long expect, long update);

CAS是如何导致ABA的尼，什么是ABA？

线程1准备用CAS修改变量值A，在此之前，其它线程将变量的值由A替换为B，又由B替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。但实际上这时的现场已经和最初不同了。

public static AtomicInteger a = new AtomicInteger(1);
    public static void main(String[] args){
        Thread main = new Thread(() -> {
            System.out.println("操作线程" + Thread.currentThread() +",初始值 = " + a);  //定义变量 a = 1
            try {
                Thread.sleep(1000);  //等待1秒 ，以便让干扰线程执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean isCASSuccess = a.compareAndSet(1,2); // CAS操作
            System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);
        },"主操作线程");
    
        Thread other = new Thread(() -> {
            Thread.yield();  //确保thread-main线程优先执行
            a.incrementAndGet(); // a 加 1, a + 1 = 1 + 1 = 2
            System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ a);
            a.decrementAndGet(); // a 减 1, a - 1 = 2 - 1 = 1
            System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ a);
        },"干扰线程");
    
        main.start();
        other.start();
    }

// 输出
    > 操作线程Thread[主操作线程,5,main],初始值 = 1
    > 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2
    > 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1
    > 操作线程Thread[主操作线程,5,main],CAS操作结果: true

为了解决Atomic可能出现的ABA问题 ，jdk提供了AtomicStampedReference类，很简单 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);
            }
        }

public boolean weakCompareAndSet(V   expectedReference,
                                         V   newReference,
                                         int expectedStamp,
                                         int newStamp) {
            return compareAndSet(expectedReference, newReference,
                                 expectedStamp, newStamp);
        }
    
    
        public boolean compareAndSet(V   expectedReference,
                                     V   newReference,
                                     int expectedStamp,
                                     int newStamp) {
            Pair<V> current = pair;
            return
                expectedReference == current.reference &&
                expectedStamp == current.stamp &&
                ((newReference == current.reference &&
                  newStamp == current.stamp) ||
                 casPair(current, Pair.of(newReference, newStamp)));
        }

casPair(current, Pair.of(newReference, newStamp)));方法就是直接调用unsafe的交换方法；和上面cas java实现一样。