jdk-sandbox: comparison jdk/src/java.base/share/classes/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java

equal deleted inserted replaced

-:e331a1a5a621
+:caeef2c79243
 * 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.util.function.UnaryOperator;
-import java.util.function.BinaryOperator;
-import sun.misc.Unsafe;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.security.AccessController;
+import java.security.PrivilegedActionException;
 import java.security.PrivilegedExceptionAction;
-import java.security.PrivilegedActionException;
+import java.util.function.BinaryOperator;
+import java.util.function.UnaryOperator;
 import sun.reflect.CallerSensitive;
 import sun.reflect.Reflection;
 /**
 * A reflection-based utility that enables atomic updates to
 * 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
+* <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;  }
+*   Node getLeft() { return left; }
 *   boolean compareAndSetLeft(Node expect, Node update) {
 *     return leftUpdater.compareAndSet(this, expect, update);
 *   }
 *   // ... and so on
 * }}</pre>
 return next;
 }
 private static final class AtomicReferenceFieldUpdaterImpl<T,V>
 extends AtomicReferenceFieldUpdater<T,V> {
-private static final Unsafe unsafe = Unsafe.getUnsafe();
+private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
 private final long offset;
 private final Class<T> tclass;
 private final Class<V> vclass;
 private final Class<?> cclass;
 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) {
 this.tclass = tclass;
 if (vclass == Object.class)
 this.vclass = null;
 else
 this.vclass = vclass;
-offset = unsafe.objectFieldOffset(field);
+offset = U.objectFieldOffset(field);
 }
 /**
 * Returns true if the second classloader can be found in the first
 * classloader's delegation chain.
 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);
+return U.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);
+return U.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);
+U.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);
+U.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);
+return (V)U.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);
+return (V)U.getAndSetObject(obj, offset, newValue);
 }
 private void ensureProtectedAccess(T obj) {
 if (cclass.isInstance(obj)) {
 return;

changeset 32838	caeef2c79243
parent 25859	3317bb8137f4
child 33674	566777f73c32