AtomicReferenceFieldUpdater
原子更新对象的引用字段,字段必须为volatile修饰。AtomicReferenceFieldUpdater 是一个抽象类,通过一个工厂方法获得该抽象类子类的实例。
构造方法
- protected AtomicReferenceFieldUpdater() 受保护的构造方法 使用下面工厂方法代替
// tclass为对象字段持有Class vclass为字段对象Class fieldName为字段名 public static <U,W> AtomicReferenceFieldUpdater<U,W> newUpdater(Class<U> tclass, Class<W> vclass, String fieldName) { return new AtomicReferenceFieldUpdaterImpl<U,W> (tclass, vclass, fieldName, Reflection.getCallerClass()); }
静态内部类
private static final class AtomicReferenceFieldUpdaterImpl<T,V>
extends AtomicReferenceFieldUpdater<T,V> {
// Unsafe实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 对象字段偏移量
private final long offset;
// 对象字段持有对象Class
private final Class<T> tclass;
// 对象字段Class
private final Class<V> vclass;
// caller Class
private final Class<?> cclass;
/*
* Internal type checks within all update methods contain
* internal inlined optimizations checking for the common
* cases where the class is final (in which case a simple
* getClass comparison suffices) or is of type Object (in
* which case no check is needed because all objects are
* instances of Object). The Object case is handled simply by
* setting vclass to null in constructor. The targetCheck and
* updateCheck methods are invoked when these faster
* screenings fail.
*/
AtomicReferenceFieldUpdaterImpl(final Class<T> tclass,
final Class<V> vclass,
final String fieldName,
final Class<?> caller) {
final Field field;
final Class<?> fieldClass;
final int modifiers;
try {
// AccessController 根据当前有效的安全策略决定是否允许或拒绝对关键资源的访问
// 根据字段名获得Field
field = AccessController.doPrivileged(
new PrivilegedExceptionAction<Field>() {
public Field run() throws NoSuchFieldException {
return tclass.getDeclaredField(fieldName);
}
});
// 获得字段修饰符
modifiers = field.getModifiers();
// 验证caller与tclass、tclass与字段之间的访问权限
sun.reflect.misc.ReflectUtil.ensureMemberAccess(
caller, tclass, null, modifiers);
ClassLoader cl = tclass.getClassLoader();
ClassLoader ccl = caller.getClassLoader();
if ((ccl != null) && (ccl != cl) &&
((cl == null) || !isAncestor(cl, ccl))) {
sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
}
fieldClass = field.getType();
} catch (PrivilegedActionException pae) {
throw new RuntimeException(pae.getException());
} catch (Exception ex) {
throw new RuntimeException(ex);
}
// 字段Class一致
if (vclass != fieldClass)
throw new ClassCastException();
// 字段Class必须为引用类型
if (vclass.isPrimitive())
throw new IllegalArgumentException("Must be reference type");
// 字段必须为volatile修饰
if (!Modifier.isVolatile(modifiers))
throw new IllegalArgumentException("Must be volatile type");
this.cclass = (Modifier.isProtected(modifiers) &&
caller != tclass) ? caller : null;
this.tclass = tclass;
if (vclass == Object.class)
this.vclass = null;
else
this.vclass = vclass;
offset = unsafe.objectFieldOffset(field);
}
/**
* Returns true if the second classloader can be found in the first
* classloader's delegation chain.
* Equivalent to the inaccessible: first.isAncestor(second).
*/
// 校验first ClassLoader是否是second ClassLoader的父类
private static boolean isAncestor(ClassLoader first, ClassLoader second) {
ClassLoader acl = first;
do {
acl = acl.getParent();
if (second == acl) {
return true;
}
} while (acl != null);
return false;
}
// 读校验
void targetCheck(T obj) {
if (!tclass.isInstance(obj))
throw new ClassCastException();
if (cclass != null)
ensureProtectedAccess(obj);
}
// 写校验
void updateCheck(T obj, V update) {
// obj不是字段持有Class的实例或者update不是字段Class实例
if (!tclass.isInstance(obj) ||
(update != null && vclass != null && !vclass.isInstance(update)))
throw new ClassCastException();
if (cclass != null)
ensureProtectedAccess(obj);
}
// 比较实例字段的值并替换
public boolean compareAndSet(T obj, V expect, V update) {
if (obj == null || obj.getClass() != tclass || cclass != null ||
(update != null && vclass != null &&
vclass != update.getClass()))
updateCheck(obj, update);
return unsafe.compareAndSwapObject(obj, offset, expect, update);
}
// 同compareAndSet
public boolean weakCompareAndSet(T obj, V expect, V update) {
// same implementation as strong form for now
if (obj == null || obj.getClass() != tclass || cclass != null ||
(update != null && vclass != null &&
vclass != update.getClass()))
updateCheck(obj, update);
return unsafe.compareAndSwapObject(obj, offset, expect, update);
}
// putObjectVolatile保证set后立刻被其他线程看到
public void set(T obj, V newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null ||
(newValue != null && vclass != null &&
vclass != newValue.getClass()))
updateCheck(obj, newValue);
unsafe.putObjectVolatile(obj, offset, newValue);
}
// putObjectVolatile的延迟实现 不能保证set后立刻被其他线程看到
public void lazySet(T obj, V newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null ||
(newValue != null && vclass != null &&
vclass != newValue.getClass()))
updateCheck(obj, newValue);
unsafe.putOrderedObject(obj, offset, newValue);
}
// 获得引用字段最新值
@SuppressWarnings("unchecked")
public V get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null)
targetCheck(obj);
return (V)unsafe.getObjectVolatile(obj, offset);
}
// 设置引用字段为新值 返回旧值
@SuppressWarnings("unchecked")
public V getAndSet(T obj, V newValue) {
if (obj == null || obj.getClass() != tclass || cclass != null ||
(newValue != null && vclass != null &&
vclass != newValue.getClass()))
updateCheck(obj, newValue);
return (V)unsafe.getAndSetObject(obj, offset, newValue);
}
// 确保obj的Class能访问
private void ensureProtectedAccess(T obj) {
if (cclass.isInstance(obj)) {
return;
}
throw new RuntimeException(
new IllegalAccessException("Class " +
cclass.getName() +
" can not access a protected member of class " +
tclass.getName() +
" using an instance of " +
obj.getClass().getName()
)
);
}
}
方法
抽象方法
// 见AtomicReferenceFieldUpdaterImpl中compareAndSet方法
public abstract boolean compareAndSet(T obj, V expect, V update);
// 见AtomicReferenceFieldUpdaterImpl中weakCompareAndSet方法
public abstract boolean weakCompareAndSet(T obj, V expect, V update);
// 见AtomicReferenceFieldUpdaterImpl中set方法
public abstract void set(T obj, V newValue);
// 见AtomicReferenceFieldUpdaterImpl中lazySet方法
public abstract void lazySet(T obj, V newValue);
// 见AtomicReferenceFieldUpdaterImpl中get方法
public abstract V get(T obj);
V getAndSet(T obj, V newValue)
// 修改引用字段值 返回旧值
// 默认cas实现
// AtomicReferenceFieldUpdaterImpl已经重写此方法 使用getAndSetObject实现
public V getAndSet(T obj, V newValue) {
V prev;
do {
prev = get(obj);
} while (!compareAndSet(obj, prev, newValue));
return prev;
}
V getAndUpdate(T obj, UnaryOperator<V> updateFunction)
// 对引用字段进行一元操作 返回操作前的值
// cas实现
public final V getAndUpdate(T obj, UnaryOperator<V> updateFunction) {
V prev, next;
do {
prev = get(obj);
next = updateFunction.apply(prev);
} while (!compareAndSet(obj, prev, next));
return prev;
}
V updateAndGet(T obj, UnaryOperator<V> updateFunction)
// 对引用字段进行一元操作 返回操作后的值
// cas实现
public final V updateAndGet(T obj, UnaryOperator<V> updateFunction) {
V prev, next;
do {
prev = get(obj);
next = updateFunction.apply(prev);
} while (!compareAndSet(obj, prev, next));
return next;
}
V getAndAccumulate(T obj, V x, BinaryOperator<V> accumulatorFunction)
// 对引用字段进行二元操作 返回操作前的值
// cas实现
public final V getAndAccumulate(T obj, V x,
BinaryOperator<V> accumulatorFunction) {
V prev, next;
do {
prev = get(obj);
next = accumulatorFunction.apply(prev, x);
} while (!compareAndSet(obj, prev, next));
return prev;
}
V accumulateAndGet(T obj, V x, BinaryOperator<V> accumulatorFunction)
// 对引用字段进行二元操作 返回操作后的值
// cas实现
public final V accumulateAndGet(T obj, V x,
BinaryOperator<V> accumulatorFunction) {
V prev, next;
do {
prev = get(obj);
next = accumulatorFunction.apply(prev, x);
} while (!compareAndSet(obj, prev, next));
return next;
}