Source for java.util.concurrent.atomic.AtomicLongFieldUpdater

   1: /*
   2:  * Written by Doug Lea with assistance from members of JCP JSR-166
   3:  * Expert Group and released to the public domain, as explained at
   4:  * http://creativecommons.org/licenses/publicdomain
   5:  */
   6: 
   7: package java.util.concurrent.atomic;
   8: import sun.misc.Unsafe;
   9: import java.lang.reflect.*;
  10: 
  11: /**
  12:  * A reflection-based utility that enables atomic updates to
  13:  * designated <tt>volatile long</tt> fields of designated classes.
  14:  * This class is designed for use in atomic data structures in which
  15:  * several fields of the same node are independently subject to atomic
  16:  * updates.
  17:  *
  18:  * <p>Note that the guarantees of the {@code compareAndSet}
  19:  * method in this class are weaker than in other atomic classes.
  20:  * Because this class cannot ensure that all uses of the field
  21:  * are appropriate for purposes of atomic access, it can
  22:  * guarantee atomicity only with respect to other invocations of
  23:  * {@code compareAndSet} and {@code set} on the same updater.
  24:  *
  25:  * @since 1.5
  26:  * @author Doug Lea
  27:  * @param <T> The type of the object holding the updatable field
  28:  */
  29: public abstract class  AtomicLongFieldUpdater<T>  {
  30:     /**
  31:      * Creates and returns an updater for objects with the given field.
  32:      * The Class argument is needed to check that reflective types and
  33:      * generic types match.
  34:      *
  35:      * @param tclass the class of the objects holding the field
  36:      * @param fieldName the name of the field to be updated.
  37:      * @return the updater
  38:      * @throws IllegalArgumentException if the field is not a
  39:      * volatile long type.
  40:      * @throws RuntimeException with a nested reflection-based
  41:      * exception if the class does not hold field or is the wrong type.
  42:      */
  43:     public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) {
  44:         if (AtomicLong.VM_SUPPORTS_LONG_CAS)
  45:             return new CASUpdater<U>(tclass, fieldName);
  46:         else
  47:             return new LockedUpdater<U>(tclass, fieldName);
  48:     }
  49: 
  50:     /**
  51:      * Protected do-nothing constructor for use by subclasses.
  52:      */
  53:     protected AtomicLongFieldUpdater() {
  54:     }
  55: 
  56:     /**
  57:      * Atomically sets the field of the given object managed by this updater
  58:      * to the given updated value if the current value <tt>==</tt> the
  59:      * expected value. This method is guaranteed to be atomic with respect to
  60:      * other calls to <tt>compareAndSet</tt> and <tt>set</tt>, but not
  61:      * necessarily with respect to other changes in the field.
  62:      *
  63:      * @param obj An object whose field to conditionally set
  64:      * @param expect the expected value
  65:      * @param update the new value
  66:      * @return true if successful.
  67:      * @throws ClassCastException if <tt>obj</tt> is not an instance
  68:      * of the class possessing the field established in the constructor.
  69:      */
  70:     public abstract boolean compareAndSet(T obj, long expect, long update);
  71: 
  72:     /**
  73:      * Atomically sets the field of the given object managed by this updater
  74:      * to the given updated value if the current value <tt>==</tt> the
  75:      * expected value. This method is guaranteed to be atomic with respect to
  76:      * other calls to <tt>compareAndSet</tt> and <tt>set</tt>, but not
  77:      * necessarily with respect to other changes in the field.
  78:      * May fail spuriously and does not provide ordering guarantees,
  79:      * so is only rarely an appropriate alternative to <tt>compareAndSet</tt>.
  80:      *
  81:      * @param obj An object whose field to conditionally set
  82:      * @param expect the expected value
  83:      * @param update the new value
  84:      * @return true if successful.
  85:      * @throws ClassCastException if <tt>obj</tt> is not an instance
  86:      * of the class possessing the field established in the constructor.
  87:      */
  88:     public abstract boolean weakCompareAndSet(T obj, long expect, long update);
  89: 
  90:     /**
  91:      * Sets the field of the given object managed by this updater to the
  92:      * given updated value. This operation is guaranteed to act as a volatile
  93:      * store with respect to subsequent invocations of
  94:      * <tt>compareAndSet</tt>.
  95:      *
  96:      * @param obj An object whose field to set
  97:      * @param newValue the new value
  98:      */
  99:     public abstract void set(T obj, long newValue);
 100: 
 101:     /**
 102:      * Eventually sets the field of the given object managed by this
 103:      * updater to the given updated value.
 104:      *
 105:      * @param obj An object whose field to set
 106:      * @param newValue the new value
 107:      * @since 1.6
 108:      */
 109:     public abstract void lazySet(T obj, long newValue);
 110: 
 111:     /**
 112:      * Gets the current value held in the field of the given object managed
 113:      * by this updater.
 114:      *
 115:      * @param obj An object whose field to get
 116:      * @return the current value
 117:      */
 118:     public abstract long get(T obj);
 119: 
 120:     /**
 121:      * Atomically sets the field of the given object managed by this updater
 122:      * to the given value and returns the old value.
 123:      *
 124:      * @param obj An object whose field to get and set
 125:      * @param newValue the new value
 126:      * @return the previous value
 127:      */
 128:     public long getAndSet(T obj, long newValue) {
 129:         for (;;) {
 130:             long current = get(obj);
 131:             if (compareAndSet(obj, current, newValue))
 132:                 return current;
 133:         }
 134:     }
 135: 
 136:     /**
 137:      * Atomically increments by one the current value of the field of the
 138:      * given object managed by this updater.
 139:      *
 140:      * @param obj An object whose field to get and set
 141:      * @return the previous value
 142:      */
 143:     public long getAndIncrement(T obj) {
 144:         for (;;) {
 145:             long current = get(obj);
 146:             long next = current + 1;
 147:             if (compareAndSet(obj, current, next))
 148:                 return current;
 149:         }
 150:     }
 151: 
 152:     /**
 153:      * Atomically decrements by one the current value of the field of the
 154:      * given object managed by this updater.
 155:      *
 156:      * @param obj An object whose field to get and set
 157:      * @return the previous value
 158:      */
 159:     public long getAndDecrement(T obj) {
 160:         for (;;) {
 161:             long current = get(obj);
 162:             long next = current - 1;
 163:             if (compareAndSet(obj, current, next))
 164:                 return current;
 165:         }
 166:     }
 167: 
 168:     /**
 169:      * Atomically adds the given value to the current value of the field of
 170:      * the given object managed by this updater.
 171:      *
 172:      * @param obj An object whose field to get and set
 173:      * @param delta the value to add
 174:      * @return the previous value
 175:      */
 176:     public long getAndAdd(T obj, long delta) {
 177:         for (;;) {
 178:             long current = get(obj);
 179:             long next = current + delta;
 180:             if (compareAndSet(obj, current, next))
 181:                 return current;
 182:         }
 183:     }
 184: 
 185:     /**
 186:      * Atomically increments by one the current value of the field of the
 187:      * given object managed by this updater.
 188:      *
 189:      * @param obj An object whose field to get and set
 190:      * @return the updated value
 191:      */
 192:     public long incrementAndGet(T obj) {
 193:         for (;;) {
 194:             long current = get(obj);
 195:             long next = current + 1;
 196:             if (compareAndSet(obj, current, next))
 197:                 return next;
 198:         }
 199:     }
 200: 
 201:     /**
 202:      * Atomically decrements by one the current value of the field of the
 203:      * given object managed by this updater.
 204:      *
 205:      * @param obj An object whose field to get and set
 206:      * @return the updated value
 207:      */
 208:     public long decrementAndGet(T obj) {
 209:         for (;;) {
 210:             long current = get(obj);
 211:             long next = current - 1;
 212:             if (compareAndSet(obj, current, next))
 213:                 return next;
 214:         }
 215:     }
 216: 
 217:     /**
 218:      * Atomically adds the given value to the current value of the field of
 219:      * the given object managed by this updater.
 220:      *
 221:      * @param obj An object whose field to get and set
 222:      * @param delta the value to add
 223:      * @return the updated value
 224:      */
 225:     public long addAndGet(T obj, long delta) {
 226:         for (;;) {
 227:             long current = get(obj);
 228:             long next = current + delta;
 229:             if (compareAndSet(obj, current, next))
 230:                 return next;
 231:         }
 232:     }
 233: 
 234:     private static class CASUpdater<T> extends AtomicLongFieldUpdater<T> {
 235:         private static final Unsafe unsafe = Unsafe.getUnsafe();
 236:         private final long offset;
 237:         private final Class<T> tclass;
 238:         private final Class cclass;
 239: 
 240:         CASUpdater(Class<T> tclass, String fieldName) {
 241:             Field field = null;
 242:         Class caller = null;
 243:         int modifiers = 0;
 244:             try {
 245:                 field = tclass.getDeclaredField(fieldName);
 246:         caller = sun.reflect.Reflection.getCallerClass(3);
 247:         modifiers = field.getModifiers();
 248:                 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
 249:                     caller, tclass, null, modifiers); 
 250:         sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
 251:             } catch(Exception ex) {
 252:                 throw new RuntimeException(ex);
 253:             }
 254: 
 255:             Class fieldt = field.getType();
 256:             if (fieldt != long.class)
 257:                 throw new IllegalArgumentException("Must be long type");
 258: 
 259:             if (!Modifier.isVolatile(modifiers))
 260:                 throw new IllegalArgumentException("Must be volatile type");
 261: 
 262:         this.cclass = (Modifier.isProtected(modifiers) &&
 263:                caller != tclass) ? caller : null;
 264:             this.tclass = tclass;
 265:             offset = unsafe.objectFieldOffset(field);
 266:         }
 267: 
 268:         private void fullCheck(T obj) {
 269:             if (!tclass.isInstance(obj))
 270:                 throw new ClassCastException();
 271:         if (cclass != null)
 272:             ensureProtectedAccess(obj);
 273:     }
 274: 
 275:         public boolean compareAndSet(T obj, long expect, long update) {
 276:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 277:             return unsafe.compareAndSwapLong(obj, offset, expect, update);
 278:         }
 279: 
 280:         public boolean weakCompareAndSet(T obj, long expect, long update) {
 281:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 282:             return unsafe.compareAndSwapLong(obj, offset, expect, update);
 283:         }
 284: 
 285:         public void set(T obj, long newValue) {
 286:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 287:             unsafe.putLongVolatile(obj, offset, newValue);
 288:         }
 289: 
 290:         public void lazySet(T obj, long newValue) {
 291:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 292:             unsafe.putOrderedLong(obj, offset, newValue);
 293:         }
 294: 
 295:         public long get(T obj) {
 296:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 297:             return unsafe.getLongVolatile(obj, offset);
 298:         }
 299: 
 300:     private void ensureProtectedAccess(T obj) {
 301:         if (cclass.isInstance(obj)) {
 302:         return;
 303:         }
 304:         throw new RuntimeException (
 305:                 new IllegalAccessException("Class " +
 306:             cclass.getName() +
 307:                     " can not access a protected member of class " +
 308:                     tclass.getName() +
 309:             " using an instance of " +
 310:                     obj.getClass().getName()
 311:         )
 312:         );
 313:     }
 314:     }
 315: 
 316: 
 317:     private static class LockedUpdater<T> extends AtomicLongFieldUpdater<T> {
 318:         private static final Unsafe unsafe = Unsafe.getUnsafe();
 319:         private final long offset;
 320:         private final Class<T> tclass;
 321:         private final Class cclass;
 322: 
 323:         LockedUpdater(Class<T> tclass, String fieldName) {
 324:             Field field = null;
 325:         Class caller = null;
 326:         int modifiers = 0;
 327:             try {
 328:                 field = tclass.getDeclaredField(fieldName);
 329:         caller = sun.reflect.Reflection.getCallerClass(3);
 330:         modifiers = field.getModifiers();
 331:                 sun.reflect.misc.ReflectUtil.ensureMemberAccess(
 332:                     caller, tclass, null, modifiers); 
 333:         sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
 334:             } catch(Exception ex) {
 335:                 throw new RuntimeException(ex);
 336:             }
 337: 
 338:             Class fieldt = field.getType();
 339:             if (fieldt != long.class)
 340:                 throw new IllegalArgumentException("Must be long type");
 341: 
 342:             if (!Modifier.isVolatile(modifiers))
 343:                 throw new IllegalArgumentException("Must be volatile type");
 344: 
 345:         this.cclass = (Modifier.isProtected(modifiers) &&
 346:                caller != tclass) ? caller : null;
 347:             this.tclass = tclass;
 348:             offset = unsafe.objectFieldOffset(field);
 349:         }
 350: 
 351:         private void fullCheck(T obj) {
 352:             if (!tclass.isInstance(obj))
 353:                 throw new ClassCastException();
 354:         if (cclass != null)
 355:             ensureProtectedAccess(obj);
 356:     }
 357: 
 358:         public boolean compareAndSet(T obj, long expect, long update) {
 359:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 360:             synchronized(this) {
 361:                 long v = unsafe.getLong(obj, offset);
 362:                 if (v != expect)
 363:                     return false;
 364:                 unsafe.putLong(obj, offset, update);
 365:                 return true;
 366:             }
 367:         }
 368: 
 369:         public boolean weakCompareAndSet(T obj, long expect, long update) {
 370:             return compareAndSet(obj, expect, update);
 371:         }
 372: 
 373:         public void set(T obj, long newValue) {
 374:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 375:             synchronized(this) {
 376:                 unsafe.putLong(obj, offset, newValue);
 377:             }
 378:         }
 379: 
 380:         public void lazySet(T obj, long newValue) {
 381:         set(obj, newValue);
 382:         }
 383: 
 384:         public long get(T obj) {
 385:             if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj);
 386:             synchronized(this) {
 387:                 return unsafe.getLong(obj, offset);
 388:             }
 389:         }
 390: 
 391:     private void ensureProtectedAccess(T obj) {
 392:         if (cclass.isInstance(obj)) {
 393:         return;
 394:         }
 395:         throw new RuntimeException (
 396:                 new IllegalAccessException("Class " +
 397:             cclass.getName() +
 398:                     " can not access a protected member of class " +
 399:                     tclass.getName() +
 400:             " using an instance of " +
 401:                     obj.getClass().getName()
 402:         )
 403:         );
 404:     }
 405:     }
 406: }