volatile类型变量更新

      volatile类型的实例变量的修改，JDK提供了J.U.C下的atomic包下类来支持。
       1、AtomicInteger/AtomicLong/AtomicBoolean/AtomicReference是关于对变量的原子更新，
       2、AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray是关于对数组的原子更新
       3、AtomicIntegerFieldUpdater<T>/AtomicLongFieldUpdater<T>/AtomicReferenceFieldUpdater<T,V>是基于反射的原子更新字段的值。
      这里也有一些约束，只能是非final的实例变量，并且被volatile修饰。

 

简单示例：

public class Mock {
    private volatile String[] name = new String[]{};
    private volatile int index = 0;

    private static AtomicIntegerFieldUpdater indexUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Mock.class, "index");
    private static final AtomicReferenceFieldUpdater<Mock, String[]> nameUpdater =
            AtomicReferenceFieldUpdater.newUpdater(Mock.class, String[].class, "name");

    public int getAndIncrementIndex() {
        return indexUpdater.getAndIncrement(this);
    }

    public String[] getName() {
        nameUpdater.set(this, new String[]{"zero"});
        return nameUpdater.get(this);
    }
}

      AtomicXxxFieldUpdater本质上通过sun.misc.Unsafe来完成操作，在java.util.concurrent.locks包中可以发现很多Unsafe的使用痕迹，例如AbstractQueuedSynchronizer。
      Unsafe提供了static方法来获取Unsafe的类变量theUnsafe，即一个Unsafe对象：

@CallerSensitive
public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

      但是，可以发现，只有调用类的ClassLoader是Bootstrp ClassLoader能返回这个theUnsafe，否则会抛出SecurityException异常。因为这个类如其名，unsafe，该类设计初衷也不想被应用程序使用，只能被rt.jar中的类使用。但是实际上是可以通过反射机制拿到这个值的：

public class UnsafeFactory {
    private static final Unsafe UNSAFE;

    static {
        Unsafe unsafe;
        try {
            Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
            unsafeField.setAccessible(true);
            unsafe = (Unsafe) unsafeField.get(null);
        } catch (Throwable t) {
            System.out.println("sun.misc.Unsafe.theUnsafe: unavailable, {}.");
            unsafe = null;
        }
        UNSAFE = unsafe;
    }

    public static Unsafe getUnsafe() {
        return UNSAFE;
    }

    private UnsafeFactory() {
        throw new RuntimeException("Cann't Access UnsafeFactory Constructor");
    }
}

      然后就可以用Unsafe来完成对volatile变量的修改:

public class Mock {
    private volatile int index = 0;

    private static final Unsafe unsafe = UnsafeFactory.getUnsafe();
    private static final long indexOffset;

    static {
        try {
            indexOffset = unsafe.objectFieldOffset(Mock.class.getDeclaredField("index"));
        } catch (Exception ex) {
            throw new Error(ex);
        }
    }

    public int getAndAddIndex(int i) {
       return unsafe.getAndAddInt(this, indexOffset, i);
    }
}

--------------------补充-----------------------------

       在Atomic包里一共有12个类，四种原子更新方式，分别是原子更新基本类型，原子更新数组，原子更新引用和原子更新字段。Atomic包里的类基本都是使用Unsafe实现的包装类。

原子更新基本类型类
用于通过原子的方式更新基本类型，Atomic包提供了以下三个类：
    • AtomicBoolean：原子更新布尔类型。
    • AtomicInteger：原子更新整型。
    • AtomicLong：原子更新长整型。

原子更新数组类
通过原子的方式更新数组里的某个元素，Atomic包提供了以下三个类：
    • AtomicIntegerArray：原子更新整型数组里的元素。
    • AtomicLongArray：原子更新长整型数组里的元素。
    • AtomicReferenceArray：原子更新引用类型数组里的元素。

原子更新引用类型
原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子的更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下三个类：
    • AtomicReference：原子更新引用类型。
    • AtomicReferenceFieldUpdater：原子更新引用类型里的字段。
    • AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子的更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference(V initialRef, boolean initialMark)

原子更新字段类
如果只需要某个类里的某个字段，那么就需要使用原子更新字段类，Atomic包提供了以下三个类：
    • AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
    • AtomicLongFieldUpdater：原子更新长整型字段的更新器。
    • AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据和数据的版本号，可以解决使用CAS进行原子更新时，可能出现的ABA问题。