Reference: http://www.cnblogs.com/skywang12345/p/java_threads_category.html
outline
Atomic IntegerField Updater, Atomic LongField Updater and Atomic Reference Field Updater are similar in principle and usage in modifying atomic types of members of classes. This chapter introduces the basic types of atoms. The contents include:
Introduction to Atomic Long Field Updater and List of Functions
An example of AtomicLong Field Updater
Atomic Long Field Updater source code analysis (based on JDK 1.7.0_40)
For reprinting, please indicate the source: http://www.cnblogs.com/skywang12345/p/3514623.html
Introduction to Atomic Long Field Updater and List of Functions
AtomicLong Field Updater can update atoms to specify "members of the'volatile long'type of class". It is based on the principle of reflection.
AtomicLong Field Updater Function List
// Protected no-operation constructor for use by subclasses. protected AtomicLongFieldUpdater() // Atomically adds a given value to the current value of the field of a given object managed by this updater. long addAndGet(T obj, long delta) // If the current value == the expected value, set the field of the given object managed by the updater atomically to the given update value. abstract boolean compareAndSet(T obj, long expect, long update) // Atomically subtract 1 from the current value of a given object field managed by this updater. long decrementAndGet(T obj) // Gets the current value managed by this updater in the field of a given object. abstract long get(T obj) // Atomically adds a given value to the current value of the field of a given object managed by this updater. long getAndAdd(T obj, long delta) // Atomically subtract 1 from the current value of a given object field managed by this updater. long getAndDecrement(T obj) // Atomically adds 1 to the current value of a given object field managed by this updater. long getAndIncrement(T obj) // Atomically set the field of a given object managed by this updater to a given value and return the old value. long getAndSet(T obj, long newValue) // Atomically add 1 to the current value of a given object field managed by this updater. long incrementAndGet(T obj) // Finally, set the field of the given object managed by this updater to the given update value. abstract void lazySet(T obj, long newValue) // Creates and returns an updater with a given field for the object. static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) // Set the field of the given object managed by this updater to the given update value. abstract void set(T obj, long newValue) // If the current value == the expected value, set the field of the given object managed by the updater atomically to the given update value. abstract boolean weakCompareAndSet(T obj, long expect, long update)
An example of AtomicLong Field Updater
// LongTest.java source code
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
public class LongFieldTest {
public static void main(String[] args) {
// Get Person's class object
Class cls = Person.class;
// New AtomicLongFieldUpdater object with passing parameters of "class object" and "corresponding name of long type in class"
AtomicLongFieldUpdater mAtoLong = AtomicLongFieldUpdater.newUpdater(cls, "id");
Person person = new Person(12345678L);
// Compare the person's "id" attribute to 1000 if the ID value is 12345678L.
mAtoLong.compareAndSet(person, 12345678L, 1000);
System.out.println("id="+person.getId());
}
}
class Person {
volatile long id;
public Person(long id) {
this.id = id;
}
public void setId(long id) {
this.id = id;
}
public long getId() {
return id;
}
}
Operation results:
id=1000
Atomic Long Field Updater source code analysis (based on JDK 1.7.0_40)
Atomic Long Field Updater complete source code
/*
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*/
/*
* Written by Doug Lea with assistance from members of JCP JSR-166
* Expert Group and released to the public domain, as explained at
* http://creativecommons.org/publicdomain/zero/1.0/
*/
package java.util.concurrent.atomic;
import java.lang.reflect.*;
import sun.misc.Unsafe;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
/**
* A reflection-based utility that enables atomic updates to
* designated {@code volatile} reference fields of designated
* classes. This class is designed for use in atomic data structures
* in which several reference fields of the same node are
* independently subject to atomic updates. For example, a tree node
* might be declared as
*
* <pre> {@code
* class Node {
* private volatile Node left, right;
*
* private static final AtomicReferenceFieldUpdater<Node, Node> leftUpdater =
* AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "left");
* private static AtomicReferenceFieldUpdater<Node, Node> rightUpdater =
* AtomicReferenceFieldUpdater.newUpdater(Node.class, Node.class, "right");
*
* Node getLeft() { return left; }
* boolean compareAndSetLeft(Node expect, Node update) {
* return leftUpdater.compareAndSet(this, expect, update);
* }
* // ... and so on
* }}</pre>
*
* <p>Note that the guarantees of the {@code compareAndSet}
* method in this class are weaker than in other atomic classes.
* Because this class cannot ensure that all uses of the field
* are appropriate for purposes of atomic access, it can
* guarantee atomicity only with respect to other invocations of
* {@code compareAndSet} and {@code set} on the same updater.
*
* @since 1.5
* @author Doug Lea
* @param <T> The type of the object holding the updatable field
* @param <V> The type of the field
*/
public abstract class AtomicReferenceFieldUpdater<T, V> {
/**
* Creates and returns an updater for objects with the given field.
* The Class arguments are needed to check that reflective types and
* generic types match.
*
* @param tclass the class of the objects holding the field.
* @param vclass the class of the field
* @param fieldName the name of the field to be updated.
* @return the updater
* @throws IllegalArgumentException if the field is not a volatile reference 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, W> AtomicReferenceFieldUpdater<U,W> newUpdater(Class<U> tclass, Class<W> vclass, String fieldName) {
return new AtomicReferenceFieldUpdaterImpl<U,W>(tclass,
vclass,
fieldName,
Reflection.getCallerClass());
}
/**
* Protected do-nothing constructor for use by subclasses.
*/
protected AtomicReferenceFieldUpdater() {
}
/**
* Atomically sets the field of the given object managed by this updater
* to the given updated value if the current value {@code ==} the
* expected value. This method is guaranteed to be atomic with respect to
* other calls to {@code compareAndSet} and {@code set}, but not
* necessarily with respect to other changes in the field.
*
* @param obj An object whose field to conditionally set
* @param expect the expected value
* @param update the new value
* @return true if successful.
*/
public abstract boolean compareAndSet(T obj, V expect, V update);
/**
* Atomically sets the field of the given object managed by this updater
* to the given updated value if the current value {@code ==} the
* expected value. This method is guaranteed to be atomic with respect to
* other calls to {@code compareAndSet} and {@code set}, but not
* necessarily with respect to other changes in the field.
*
* <p>May <a href="package-summary.html#Spurious">fail spuriously</a>
* and does not provide ordering guarantees, so is only rarely an
* appropriate alternative to {@code compareAndSet}.
*
* @param obj An object whose field to conditionally set
* @param expect the expected value
* @param update the new value
* @return true if successful.
*/
public abstract boolean weakCompareAndSet(T obj, V expect, V update);
/**
* Sets the field of the given object managed by this updater to the
* given updated value. This operation is guaranteed to act as a volatile
* store with respect to subsequent invocations of {@code compareAndSet}.
*
* @param obj An object whose field to set
* @param newValue the new value
*/
public abstract void set(T obj, V newValue);
/**
* Eventually sets the field of the given object managed by this
* updater to the given updated value.
*
* @param obj An object whose field to set
* @param newValue the new value
* @since 1.6
*/
public abstract void lazySet(T obj, V newValue);
/**
* Gets the current value held in the field of the given object managed
* by this updater.
*
* @param obj An object whose field to get
* @return the current value
*/
public abstract V get(T obj);
/**
* Atomically sets the field of the given object managed by this updater
* to the given value and returns the old value.
*
* @param obj An object whose field to get and set
* @param newValue the new value
* @return the previous value
*/
public V getAndSet(T obj, V newValue) {
for (;;) {
V current = get(obj);
if (compareAndSet(obj, current, newValue))
return current;
}
}
private static final class AtomicReferenceFieldUpdaterImpl<T,V>
extends AtomicReferenceFieldUpdater<T,V> {
private static final Unsafe unsafe = Unsafe.getUnsafe();
private final long offset;
private final Class<T> tclass;
private final Class<V> vclass;
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(Class<T> tclass,
Class<V> vclass,
String fieldName,
Class<?> caller) {
Field field = null;
Class fieldClass = 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);
fieldClass = field.getType();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
if (vclass != fieldClass)
throw new ClassCastException();
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);
}
void targetCheck(T obj) {
if (!tclass.isInstance(obj))
throw new ClassCastException();
if (cclass != null)
ensureProtectedAccess(obj);
}
void updateCheck(T obj, V update) {
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);
}
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);
}
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);
}
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);
}
public V get(T obj) {
if (obj == null || obj.getClass() != tclass || cclass != null)
targetCheck(obj);
return (V)unsafe.getObjectVolatile(obj, offset);
}
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()
)
);
}
}
}The process of LongFieldTest.java is analyzed below.
1. newUpdater()
The source code for newUpdater() is as follows:
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);
}
Note: The function of newUpdater() is to get an object of Atomic IntegerField Updater type.
It actually returns a CASUpdater object, or a LockedUpdater object; which class it returns depends on whether the JVM supports a CAS function of long type. CASUpdater and LockedUpdater are subclasses of Atomic IntegerField Updater, and their implementations are similar. The following is illustrated with CASUpdater.
The source code for the CASUpdater class is as follows:
public boolean compareAndSet(T obj, long expect, long update) {
if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
return unsafe.compareAndSwapLong(obj, offset, expect, update);
}
Description: It is actually operated through CAS functions. If the value of the long object of the class is expect, set its value to update.