Java concurrency之AtomicLongFieldUpdater原子类_动力节点Java学院整理

AtomicLongFieldUpdater示例

// LongTest.java的源码
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
public class LongFieldTest {
  public static void main(String[] args) {
    // 获取Person的class对象
    Class cls = Person.class; 
    // 新建AtomicLongFieldUpdater对象，传递参数是“class对象”和“long类型在类中对应的名称”
    AtomicLongFieldUpdater mAtoLong = AtomicLongFieldUpdater.newUpdater(cls, "id");
    Person person = new Person(12345678L);
    // 比较person的"id"属性，如果id的值为12345678L，则设置为1000。
    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;
  }
}

运行结果：

id=1000

AtomicLongFieldUpdater源码分析(基于JDK1.7.0_40)

AtomicLongFieldUpdater完整源码

 
 
 package java.util.concurrent.atomic;
 import java.lang.reflect.*;
 import sun.misc.Unsafe;
 import sun.reflect.CallerSensitive;
 import sun.reflect.Reflection;
 
 public abstract class AtomicReferenceFieldUpdater {
   
   @CallerSensitive
   public static  AtomicReferenceFieldUpdater newUpdater(Class tclass, Class vclass, String fieldName) {
     return new AtomicReferenceFieldUpdaterImpl(tclass,
 vclass,
 fieldName,
 Reflection.getCallerClass());
   }
   
   protected AtomicReferenceFieldUpdater() {
   }
   
   public abstract boolean compareAndSet(T obj, V expect, V update);
   
   public abstract boolean weakCompareAndSet(T obj, V expect, V update);
   
   public abstract void set(T obj, V newValue);
   
   public abstract void lazySet(T obj, V newValue);
   
   public abstract V get(T obj);
   
   public V getAndSet(T obj, V newValue) {
     for (;;) {
V current = get(obj);
if (compareAndSet(obj, current, newValue))
  return current;
     }
   }
   private static final class AtomicReferenceFieldUpdaterImpl
     extends AtomicReferenceFieldUpdater {
     private static final Unsafe unsafe = Unsafe.getUnsafe();
     private final long offset;
     private final Class tclass;
     private final Class vclass;
     private final Class cclass;
     
     AtomicReferenceFieldUpdaterImpl(Class tclass,
Class 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()
  )
);
     }
   }
 }

public static  AtomicLongFieldUpdater newUpdater(Class tclass, String fieldName) {
  Class caller = Reflection.getCallerClass();
  if (AtomicLong.VM_SUPPORTS_LONG_CAS)
    return new CASUpdater(tclass, fieldName, caller);
  else
    return new LockedUpdater(tclass, fieldName, caller);
}

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