JUC AtomicStampedReference源码解析 JDK8

梦里梦外; 2023-03-13 03:37 33阅读 0赞

# 前言 #

大家都知道CAS操作有ABA问题的，且ABA问题是针对引用型对象的，而AtomicStampedReference的出现就是为了解决这一问题而出现的。通过加版本号来实现。

[JUC框架 系列文章目录][JUC_]

# 成员 #

public class AtomicStampedReference<V> { 
        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) {   //静态方法以创建Pair
                return new Pair<T>(reference, stamp);
            }
        }
    
        private volatile Pair<V> pair;
    ...
    }

*  静态内部类Pair，reference成员保存你的引用型对象，stamp成员则保存你对象的版本号。
 *  AtomicStampedReference有一个volatile的`Pair<V>`成员，这样，保证了pair成员的可见性。
 *  为了让Pair对象不可变，让两个域都是final的。你没有办法修改Pair对象的成员，所以只能通过静态函数重新构造一个Pair对象。这一点很重要。
 *  你可能想问，反正静态内部类Pair是只给自己用的，何必将Pair定义成泛型类呢，完全可以如下定义。一来这样就无法使用静态函数of了，构造器是私有的只能通过这个静态函数访问构造器（注释中有解释）；二来Pair对象并不需要作为成员内部类而存在，即Pair不需要持有外部类的引用。

public class AtomicStampedReference<V> { 
        private class Pair { 
            final V reference;  //直接使用V
            final int stamp;  
            private Pair(V reference, int stamp) { 
                this.reference = reference;
                this.stamp = stamp;
            }
            //此静态函数会报错，因为这个静态域需要AtomicStampedReference的对象已存在才能得到它的泛型类型V是什么
            //一个静态域，居然依赖一个对象，所以会报错。
            static Pair of(V reference, int stamp) {   
                return new Pair(reference, stamp);
            }
        }
    
        private volatile Pair<V> pair;
    ...
    }

# 常用操作 #

public AtomicStampedReference(V initialRef, int initialStamp) { 
            pair = Pair.of(initialRef, initialStamp);
        }
        
        V getReference() { 
            return pair.reference;
        }
    
        public int getStamp() { 
            return pair.stamp;
        }

*  `getReference/getStamp`都是通过volatile的成员pair获得的，所以具有可见性。

public V get(int[] stampHolder) { 
            Pair<V> pair = this.pair;
            stampHolder[0] = pair.stamp;
            return pair.reference;
        }

*  `get`函数是为了“一次性”获得存储对象和版本号。对象通过返回值，版本号通过int数组。
 *  因为int作为参数只能值传递，而int数组是一个对象，可以引用传递，所以要使用int数组。由于只需要得到版本号，所以数组大小大于1就可以了。
 *  当然，该函数是复合操作，不具有原子性。

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)));
        }
    
        private boolean casPair(Pair<V> cmp, Pair<V> val) { 
            return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
        }
    
    //Unsafe.java
        public final native boolean compareAndSwapObject(Object o, long offset,
                                                         Object expected,
                                                         Object x);

*  首先`expectedReference == current.reference`判断旧引用，和当前的是否一样；`expectedStamp == current.stamp`判断旧版本，和当前的是否一样。
 *  `(newReference == current.reference && newStamp == current.stamp)`判断 新引用和新版本号，是否和当前的相同，一般情况下，不会满足此判断的。
 *  既然上一条不满足，则调用casPair，最终调用到Unsafe的`compareAndSwapObject`。
 *  注意，每次执行此函数时，都会重新构造Pair对象，这一点很关键。这保证调用`compareAndSwapObject`函数时，参数expected和x肯定两个不同的对象，就算最开始的expectedReference与newReference一样，且expectedStamp与newStamp一样，也会构造出一个新对象，当然这由于短路或不会执行到的。
 *  完全有可能，从`expectedStamp == current.stamp`到`casPair(current, Pair.of(newReference, newStamp))`期间，线程被切换走了，切换的时候pair成员变量已经被修改了，等切换回来，current这个局部变量就不和成员pair相等了，自然casPair会失败。

public void set(V newReference, int newStamp) { 
            Pair<V> current = pair;
            if (newReference != current.reference || newStamp != current.stamp)
                this.pair = Pair.of(newReference, newStamp);
        }

*  这是用来无条件设置的函数。因为不需要保持旧值是否相同。
 *  如果 新引用和新版本号 和 当前的 一样，那么不需要更新pair成员。

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

*  此函数只更新版本号，不更新引用对象。
 *  只需保证旧引用和当前的相同，casPair函数保证了 只有current局部变量与当前pair成员是同一个对象时，才更新。

private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
        private static final long pairOffset =
            objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
    
        static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
                                      String field, Class<?> klazz) { 
            try { 
                return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
            } catch (NoSuchFieldException e) { 
                // Convert Exception to corresponding Error
                NoSuchFieldError error = new NoSuchFieldError(field);
                error.initCause(e);
                throw error;
            }
        }

*  获得pair域的偏移量。

# 总结 #

*  最终调用Unsafe的compareAndSwapObject方法时，是不关心版本号的。compareAndSwapObject只关心是不是同一个对象。（但这样不会造成问题）
 *  虽然根据上一条，感觉可能会有问题。但是由于静态内部类Pair每次都会新构造对象出来，即使`T reference, int stamp`两个参数完全一样，也会构造出两个不同的对象，所以最终调用的compareAndSwapObject不关心版本号也没有关系。
 *  综上，版本号是在Unsafe的CAS操作上进行的附加判断，准确的说，是先判断版本号，再通过CAS操作判断对象。

[JUC_]: https://blog.csdn.net/anlian523/article/details/106598910