private void fullCheck(T obj) { if (!tclass.isInstance(obj)) throw new ClassCastException(); if (cclass != null) ensureProtectedAccess(obj); }
public void set(T obj, long newValue) { if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj); synchronized (this) { unsafe.putLong(obj, offset, newValue); } }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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. */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
/** * 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, * or the field is inaccessible to the caller according to Java language * access control */ public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName); else return new LockedUpdater<U>(tclass, fieldName); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public void lazySet(T obj, long newValue) { set(obj, newValue); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public void lazySet(T obj, long newValue) { set(obj, newValue); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public void lazySet(T obj, long newValue) { set(obj, newValue); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public boolean weakCompareAndSet(T obj, long expect, long update) { return compareAndSet(obj, expect, update); }
public void lazySet(T obj, long newValue) { set(obj, newValue); }