jdk-sandbox: comparison jdk/src/java.base/share/classes/java/lang/Class.java

equal deleted inserted replaced

-:1fa861caf840
+:2ee9017c7597
 Unsafe.getUnsafe().throwException(e.getTargetException());
 // Not reached
 return null;
 }
 }
-private volatile transient Constructor<T> cachedConstructor;
+private transient volatile Constructor<T> cachedConstructor;
-private volatile transient Class<?>       newInstanceCallerCache;
+private transient volatile Class<?>       newInstanceCallerCache;
 /**
 * Determines if the specified {@code Object} is assignment-compatible
 * with the object represented by this {@code Class}.  This method is
 else {
 return new EnclosingMethodInfo(enclosingInfo);
 }
 }
-private final static class EnclosingMethodInfo {
+private static final class EnclosingMethodInfo {
 private Class<?> enclosingClass;
 private String name;
 private String descriptor;
 private EnclosingMethodInfo(Object[] enclosingInfo) {
 ReflectionData(int redefinedCount) {
 this.redefinedCount = redefinedCount;
 }
 }
-private volatile transient SoftReference<ReflectionData<T>> reflectionData;
+private transient volatile SoftReference<ReflectionData<T>> reflectionData;
 // Incremented by the VM on each call to JVM TI RedefineClasses()
 // that redefines this class or a superclass.
-private volatile transient int classRedefinedCount = 0;
+private transient volatile int classRedefinedCount = 0;
 // Lazily create and cache ReflectionData
 private ReflectionData<T> reflectionData() {
 SoftReference<ReflectionData<T>> reflectionData = this.reflectionData;
 int classRedefinedCount = this.classRedefinedCount;
 // Generic signature handling
 private native String getGenericSignature0();
 // Generic info repository; lazily initialized
-private volatile transient ClassRepository genericInfo;
+private transient volatile ClassRepository genericInfo;
 // accessor for factory
 private GenericsFactory getFactory() {
 // create scope and factory
 return CoreReflectionFactory.make(this, ClassScope.make(this));
 catch (InvocationTargetException | NoSuchMethodException |
 IllegalAccessException ex) { return null; }
 }
 return enumConstants;
 }
-private volatile transient T[] enumConstants = null;
+private transient volatile T[] enumConstants = null;
 /**
 * Returns a map from simple name to enum constant.  This package-private
 * method is used internally by Enum to implement
 * {@code public static <T extends Enum<T>> T valueOf(Class<T>, String)}
 m.put(((Enum<?>)constant).name(), constant);
 enumConstantDirectory = m;
 }
 return enumConstantDirectory;
 }
-private volatile transient Map<String, T> enumConstantDirectory = null;
+private transient volatile Map<String, T> enumConstantDirectory = null;
 /**
 * Casts an object to the class or interface represented
 * by this {@code Class} object.
 *
 }
 }
 // Annotations cache
 @SuppressWarnings("UnusedDeclaration")
-private volatile transient AnnotationData annotationData;
+private transient volatile AnnotationData annotationData;
 private AnnotationData annotationData() {
 while (true) { // retry loop
 AnnotationData annotationData = this.annotationData;
 int classRedefinedCount = this.classRedefinedCount;
 }
 // Annotation types cache their internal (AnnotationType) form
 @SuppressWarnings("UnusedDeclaration")
-private volatile transient AnnotationType annotationType;
+private transient volatile AnnotationType annotationType;
 boolean casAnnotationType(AnnotationType oldType, AnnotationType newType) {
 return Atomic.casAnnotationType(this, oldType, newType);
 }

changeset 32649	2ee9017c7597
parent 31671	362e0c0acece
child 33674	566777f73c32