Java中的CAS和ABA问题说明

/**

* 第一个参数var1代表给定对象，第二个参数var2代表var1对象在内存中的偏移量，第三个参数var3为期望修改* 的对象旧值，第四个参数var4代表要修改的值或着说是修改后的值。

**/

public final native boolean compareAndSwapObject(Object var1, long var2, Object var3, Object var4);

    public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

    public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

    /**

    * 调用的UnSafe的getAndSetInt方法，给定值和偏移量和修改的值，

    * 获取修改的值var5作为compareAndSwapInt的第三个参数用来和var1比较相同则执行更新操作

    * while循环知道操作成功。

    *public final int getAndSetInt(Object var1, long var2, int var4) {

    *   int var5;

    *   do {

    *       var5 = this.getIntVolatile(var1, var2);

    *   } while(!this测试数据pareAndSwapInt(var1, var2, var5, var4));

    *

    *    return var5;

    *}

    **/

    public final int getAndSet( int newValue) {

        return unsafe.getAndSetInt( this , valueOffset, newValue);

    }

package java.util.concurrent.atomic;

import java.util.function.IntUnaryOperator;

import java.util.function.IntBinaryOperator;

import sun.misc.Unsafe;

public class AtomicInteger extends Number implements java.io.Serializable {

     private static final long serialVersionUID = 6214790243416807050L;

     // 获取UnSafe对象实例

     private static final Unsafe unsafe = Unsafe.getUnsafe();

     //对象在内存中的偏移量

     private static final long valueOffset;

     //初始化valueOffset

     static {

         try {

             valueOffset = unsafe.objectFieldOffset

                 (AtomicInteger. class .getDeclaredField( "value" ));

         } catch (Exception ex) { throw new Error(ex); }

     }

     //对象属性值

     private volatile int value;

     public AtomicInteger( int initialValue) {

         value = initialValue;

     }

     public AtomicInteger() {

     }

     /**

     * 调用的UnSafe的getAndSetInt方法，给定值和偏移量和修改的值，

     * 获取修改的值var5作为compareAndSwapInt的第三个参数用来和var1比较相同则执行更新操作

     * while循环知道操作成功。

     *public final int getAndSetInt(Object var1, long var2, int var4) {

     *   int var5;

     *   do {

     *       var5 = this.getIntVolatile(var1, var2);

     *   } while(!this测试数据pareAndSwapInt(var1, var2, var5, var4));

     *

     *    return var5;

     *}

     **/

     public final int getAndSet( int newValue) {

         return unsafe.getAndSetInt( this , valueOffset, newValue);

     }

     //调用UnSafe的compareAndSwapInt方法保证CAS

     public final boolean compareAndSet( int expect, int update) {

         return unsafe测试数据pareAndSwapInt( this , valueOffset, expect, update);

     }

     //调用UnSafe的compareAndSwapInt方法保证CAS

     public final boolean weakCompareAndSet( int expect, int update) {

         return unsafe测试数据pareAndSwapInt( this , valueOffset, expect, update);

     }

     //调用UnSafe的getAndAddInt再调用UnSafe的getAndSetInt方法保证CAS

     public final int getAndIncrement() {

         return unsafe.getAndAddInt( this , valueOffset, 1 );

     }

     public final int getAndDecrement() {

         return unsafe.getAndAddInt( this , valueOffset, - 1 );

     }

     .........

}

package java.util.concurrent.atomic;

public class AtomicStampedReference<V> {

    /**

     * 对象值时一个AtomicStampedReference内置对象Pair，包裹了reference和stamp两个属性

     */

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

         }

     }

     private volatile Pair<V> pair;

     /**

      * 初始化对象并初始化pair

      */

     public AtomicStampedReference(V initialRef, int initialStamp) {

         pair = Pair.of(initialRef, initialStamp);

     }

     /**

      * 比较当前对象属性值和输入原始值为真，在比较当前对象的时间stamp与期望的stamp进行比较

      * 如果也想等，就更新值和stamp

      * @param expectedReference 原始值

      * @param newReference 新值

      * @param expectedStamp 期望时间

      * @param newStamp 新时间

      * @return {@code true} if successful

      */

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

     }

     // Unsafe mechanics

     private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();

     private static final long pairOffset =

         objectFieldOffset(UNSAFE, "pair" , AtomicStampedReference. class );

     private boolean casPair(Pair<V> cmp, Pair<V> val) {

         return UNSAFE测试数据pareAndSwapObject( this , pairOffset, cmp, val);

     }

     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;

         }

     }

}