src/share/classes/java/lang/reflect/Constructor.java

Print this page
rev 3746 : [mq]: cr6565585.ao

@@ -72,18 +72,10 @@
     // generic info repository; lazily initialized
     private transient ConstructorRepository genericInfo;
     private byte[]              annotations;
     private byte[]              parameterAnnotations;
 
-    // For non-public members or members in package-private classes,
-    // it is necessary to perform somewhat expensive security checks.
-    // If the security check succeeds for a given class, it will
-    // always succeed (it is not affected by the granting or revoking
-    // of permissions); we speed up the check in the common case by
-    // remembering the last Class for which the check succeeded.
-    private volatile Class<?> securityCheckCache;
-
     // Generics infrastructure
     // Accessor for factory
     private GenericsFactory getFactory() {
         // create scope and factory
         return CoreReflectionFactory.make(this, ConstructorScope.make(this));

@@ -516,20 +508,21 @@
                IllegalArgumentException, InvocationTargetException
     {
         if (!override) {
             if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
                 Class<?> caller = Reflection.getCallerClass(2);
-                if (securityCheckCache != caller) {
-                    Reflection.ensureMemberAccess(caller, clazz, null, modifiers);
-                    securityCheckCache = caller;
-                }
+
+                checkAccess(caller, clazz, null, modifiers);
             }
         }
         if ((clazz.getModifiers() & Modifier.ENUM) != 0)
             throw new IllegalArgumentException("Cannot reflectively create enum objects");
-        if (constructorAccessor == null) acquireConstructorAccessor();
-        return (T) constructorAccessor.newInstance(initargs);
+        ConstructorAccessor ca = constructorAccessor;   // read volatile
+        if (ca == null) {
+            ca = acquireConstructorAccessor();
+        }
+        return (T) ca.newInstance(initargs);
     }
 
     /**
      * Returns {@code true} if this constructor was declared to take
      * a variable number of arguments; returns {@code false}

@@ -558,24 +551,26 @@
     // NOTE that there is no synchronization used here. It is correct
     // (though not efficient) to generate more than one
     // ConstructorAccessor for a given Constructor. However, avoiding
     // synchronization will probably make the implementation more
     // scalable.
-    private void acquireConstructorAccessor() {
+    private ConstructorAccessor acquireConstructorAccessor() {
         // First check to see if one has been created yet, and take it
         // if so.
         ConstructorAccessor tmp = null;
         if (root != null) tmp = root.getConstructorAccessor();
         if (tmp != null) {
             constructorAccessor = tmp;
-            return;
-        }
+        } else {
         // Otherwise fabricate one and propagate it up to the root
         tmp = reflectionFactory.newConstructorAccessor(this);
         setConstructorAccessor(tmp);
     }
 
+        return tmp;
+    }
+
     // Returns ConstructorAccessor for this Constructor object, not
     // looking up the chain to the root
     ConstructorAccessor getConstructorAccessor() {
         return constructorAccessor;
     }