Jdk1.6 JUC源码解析(3)-atomic-AtomicXXXFieldUpdater
作者：大飞
功能简介：
- 原子域更新器，一般用于一些原子同步结构中。
源码分析：
- 首先看下AtomicIntegerFieldUpdater，AtomicIntegerFieldUpdater本身是一个抽象类，提供了一个静态工厂方法来生成实例：
public abstract class AtomicIntegerFieldUpdater<T> {
/**
* Creates and returns an updater for objects with the given field.
* The Class argument is needed to check that reflective types and
* generic types match.
*
* @param tclass the class of the objects holding the field
* @param fieldName the name of the field to be updated
* @return the updater
* @throws IllegalArgumentException if the field is not a
* volatile integer type
* @throws RuntimeException with a nested reflection-based
* exception if the class does not hold field or is the wrong type
*/
@CallerSensitive
public static <U> AtomicIntegerFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
return new AtomicIntegerFieldUpdaterImpl<U>(tclass, fieldName, Reflection.getCallerClass());
}
/**
* Protected do-nothing constructor for use by subclasses.
*/
protected AtomicIntegerFieldUpdater() {
}这个方法内部会创建一个AtomicIntegerFieldUpdaterImpl的实例。看一下实现：
private static class AtomicIntegerFieldUpdaterImpl<T> extends AtomicIntegerFieldUpdater<T> {
private static final Unsafe unsafe = Unsafe.getUnsafe();
private final long offset;
private final Class<T> tclass;
private final Class cclass;
AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName, Class<?> caller) {
Field field = null;
int modifiers = 0;
try {
field = tclass.getDeclaredField(fieldName);
modifiers = field.getModifiers();
sun.reflect.misc.ReflectUtil.ensureMemberAccess(
caller, tclass, null, modifiers);
sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
} catch(Exception ex) {
throw new RuntimeException(ex);
}
Class fieldt = field.getType();
if (fieldt != int.class)
throw new IllegalArgumentException("Must be integer type");
if (!Modifier.isVolatile(modifiers))
throw new IllegalArgumentException("Must be volatile type");
this.cclass = (Modifier.isProtected(modifiers) &&
caller != tclass) ? caller : null;
this.tclass = tclass;
offset = unsafe.objectFieldOffset(field);
}AtomicIntegerFieldUpdaterImpl构造过程中会目标class，和目标域的访问权限、还要要检查目标域是否为int型，是否由volatile修饰、当然还要获取目标域的偏移量，为后面的CAS操作做准备。 内部基本上就是调用unsafe的方法了，这些方法前面和AtomicInteger源码分析中都描述过了。
public boolean compareAndSet(T obj, int expect, int update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.compareAndSwapInt(obj, offset, expect, update);
}
public boolean weakCompareAndSet(T obj, int expect, int update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.compareAndSwapInt(obj, offset, expect, update);
}
public void set(T obj, int newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
unsafe.putIntVolatile(obj, offset, newValue);
}
public void lazySet(T obj, int newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
unsafe.putOrderedInt(obj, offset, newValue);
}
public final int get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.getIntVolatile(obj, offset);
}AtomicIntegerFieldUpdater中的其他方法都是基于这些方法来实现的：
/**
* Atomically increments by one the current value of the field of the
* given object managed by this updater.
*
* @param obj An object whose field to get and set
* @return the updated value
*/
public int incrementAndGet(T obj) {
for (;;) {
int current = get(obj);
int next = current + 1;
if (compareAndSet(obj, current, next))
return next;
}
}
- 再看下AtomicLongFieldUpdater，结构和AtomicIntegerFieldUpdater类似，有一点区别就是，它有两个实现，根据平台是否支持8字节的CAS操作，来选择不同的实现：
public abstract class AtomicLongFieldUpdater<T> {
/**
* Creates and returns an updater for objects with the given field.
* The Class argument is needed to check that reflective types and
* generic types match.
*
* @param tclass the class of the objects holding the field
* @param fieldName the name of the field to be updated.
* @return the updater
* @throws IllegalArgumentException if the field is not a
* volatile long type.
* @throws RuntimeException with a nested reflection-based
* exception if the class does not hold field or is the wrong type.
*/
@CallerSensitive
public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
Class<?> caller = Reflection.getCallerClass();
if (AtomicLong.VM_SUPPORTS_LONG_CAS)
return new CASUpdater<U>(tclass, fieldName, caller);
else
return new LockedUpdater<U>(tclass, fieldName, caller);
}CAS实现就是和AtomicIntegerFieldUpdater中类似的实现，LockedUpdater是实现就是内部加锁：
public boolean compareAndSet(T obj, long expect, long update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
synchronized(this) {
long v = unsafe.getLong(obj, offset);
if (v != expect)
return false;
unsafe.putLong(obj, offset, update);
return true;
}
}
- 最后看下AtomicReferenceFieldUpdater。
AtomicReferenceFieldUpdater和AtomicIntegerFieldUpdater类似的结构，AtomicReferenceFieldUpdater一般用于某些原子数据结构中，支持某些节点的引用域的独立原子更新操作。
其实直接使用AtomicReference也可以完成类似的工作，那么为什么要使用AtomicReferenceFieldUpdater？主要原因还是为了提高性能。假设要设计一个支持原子操作的队列，队列的链接节点必然会进行频繁的操作，如果利用AtomicReference表示这些结点，那么AtomicReference本身的创建过程也需要一些开销，使用AtomicReferenceFieldUpdater可以省去这些开销。
代码细节点之前都分析到过，这里不做详细分析。
好了，源码就分析到这里！
