jdk-sandbox: comparison jdk/src/share/classes/java/lang/reflect/Proxy.java

equal deleted inserted replaced

-:692bf32a1f26
+:5e58e261911b
 * questions.
 */
 package java.lang.reflect;
-import java.lang.ref.Reference;
 import java.lang.ref.WeakReference;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.Arrays;
-import java.util.Collections;
+import java.util.IdentityHashMap;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
-import java.util.List;
+import java.util.function.BiFunction;
-import java.util.WeakHashMap;
 import sun.misc.ProxyGenerator;
 import sun.misc.VM;
 import sun.reflect.CallerSensitive;
 import sun.reflect.Reflection;
 import sun.reflect.misc.ReflectUtil;
 */
 public class Proxy implements java.io.Serializable {
 private static final long serialVersionUID = -2222568056686623797L;
-/** prefix for all proxy class names */
-private final static String proxyClassNamePrefix = "$Proxy";
 /** parameter types of a proxy class constructor */
-private final static Class[] constructorParams =
+private static final Class<?>[] constructorParams =
 { InvocationHandler.class };
-/** maps a class loader to the proxy class cache for that loader */
+/**
-private static Map<ClassLoader, Map<List<String>, Object>> loaderToCache
+* a cache of proxy classes
-= new WeakHashMap<>();
+*/
+private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
-/** marks that a particular proxy class is currently being generated */
+proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
-private static Object pendingGenerationMarker = new Object();
-/** next number to use for generation of unique proxy class names */
-private static long nextUniqueNumber = 0;
-private static Object nextUniqueNumberLock = new Object();
-/** set of all generated proxy classes, for isProxyClass implementation */
-private static Map<Class<?>, Void> proxyClasses =
-Collections.synchronizedMap(new WeakHashMap<Class<?>, Void>());
 /**
 * the invocation handler for this proxy instance.
 * @serial
 */
 Class<?>... interfaces) {
 if (interfaces.length > 65535) {
 throw new IllegalArgumentException("interface limit exceeded");
 }
-Class<?> proxyClass = null;
+// If the proxy class defined by the given loader implementing
+// the given interfaces exists, this will simply return the cached copy;
-/* collect interface names to use as key for proxy class cache */
+// otherwise, it will create the proxy class via the ProxyClassFactory
-String[] interfaceNames = new String[interfaces.length];
+return proxyClassCache.get(loader, interfaces);
+}
-// for detecting duplicates
-Set<Class<?>> interfaceSet = new HashSet<>();
+/*
+* a key used for proxy class with 0 implemented interfaces
-for (int i = 0; i < interfaces.length; i++) {
+*/
-/*
+private static final Object key0 = new Object();
-* Verify that the class loader resolves the name of this
-* interface to the same Class object.
+/*
-*/
+* Key1 and Key2 are optimized for the common use of dynamic proxies
-String interfaceName = interfaces[i].getName();
+* that implement 1 or 2 interfaces.
-Class<?> interfaceClass = null;
+*/
-try {
-interfaceClass = Class.forName(interfaceName, false, loader);
+/*
-} catch (ClassNotFoundException e) {
+* a key used for proxy class with 1 implemented interface
-}
+*/
-if (interfaceClass != interfaces[i]) {
+private static final class Key1 extends WeakReference<Class<?>> {
-throw new IllegalArgumentException(
+private final int hash;
-interfaces[i] + " is not visible from class loader");
-}
+Key1(Class<?> intf) {
+super(intf);
-/*
+this.hash = intf.hashCode();
-* Verify that the Class object actually represents an
+}
-* interface.
-*/
+@Override
-if (!interfaceClass.isInterface()) {
+public int hashCode() {
-throw new IllegalArgumentException(
+return hash;
-interfaceClass.getName() + " is not an interface");
+}
-}
+@Override
-/*
+public boolean equals(Object obj) {
-* Verify that this interface is not a duplicate.
+Class<?> intf;
-*/
+return this == obj ||
-if (interfaceSet.contains(interfaceClass)) {
+obj != null &&
-throw new IllegalArgumentException(
+obj.getClass() == Key1.class &&
-"repeated interface: " + interfaceClass.getName());
+(intf = get()) != null &&
-}
+intf == ((Key1) obj).get();
-interfaceSet.add(interfaceClass);
+}
+}
-interfaceNames[i] = interfaceName;
-}
+/*
+* a key used for proxy class with 2 implemented interfaces
-/*
+*/
-* Using string representations of the proxy interfaces as
+private static final class Key2 extends WeakReference<Class<?>> {
-* keys in the proxy class cache (instead of their Class
+private final int hash;
-* objects) is sufficient because we require the proxy
+private final WeakReference<Class<?>> ref2;
-* interfaces to be resolvable by name through the supplied
-* class loader, and it has the advantage that using a string
+Key2(Class<?> intf1, Class<?> intf2) {
-* representation of a class makes for an implicit weak
+super(intf1);
-* reference to the class.
+hash = 31 * intf1.hashCode() + intf2.hashCode();
-*/
+ref2 = new WeakReference<Class<?>>(intf2);
-List<String> key = Arrays.asList(interfaceNames);
+}
-/*
+@Override
-* Find or create the proxy class cache for the class loader.
+public int hashCode() {
-*/
+return hash;
-Map<List<String>, Object> cache;
+}
-synchronized (loaderToCache) {
-cache = loaderToCache.get(loader);
+@Override
-if (cache == null) {
+public boolean equals(Object obj) {
-cache = new HashMap<>();
+Class<?> intf1, intf2;
-loaderToCache.put(loader, cache);
+return this == obj ||
-}
+obj != null &&
-/*
+obj.getClass() == Key2.class &&
-* This mapping will remain valid for the duration of this
+(intf1 = get()) != null &&
-* method, without further synchronization, because the mapping
+intf1 == ((Key2) obj).get() &&
-* will only be removed if the class loader becomes unreachable.
+(intf2 = ref2.get()) != null &&
-*/
+intf2 == ((Key2) obj).ref2.get();
 }
+}
-/*
-* Look up the list of interfaces in the proxy class cache using
+/*
-* the key.  This lookup will result in one of three possible
+* a key used for proxy class with any number of implemented interfaces
-* kinds of values:
+* (used here for 3 or more only)
-*     null, if there is currently no proxy class for the list of
+*/
-*         interfaces in the class loader,
+private static final class KeyX {
-*     the pendingGenerationMarker object, if a proxy class for the
+private final int hash;
-*         list of interfaces is currently being generated,
+private final WeakReference<Class<?>>[] refs;
-*     or a weak reference to a Class object, if a proxy class for
-*         the list of interfaces has already been generated.
+KeyX(Class<?>[] interfaces) {
-*/
+hash = Arrays.hashCode(interfaces);
-synchronized (cache) {
+refs = new WeakReference[interfaces.length];
-/*
+for (int i = 0; i < interfaces.length; i++) {
-* Note that we need not worry about reaping the cache for
+refs[i] = new WeakReference<>(interfaces[i]);
-* entries with cleared weak references because if a proxy class
+}
-* has been garbage collected, its class loader will have been
+}
-* garbage collected as well, so the entire cache will be reaped
-* from the loaderToCache map.
+@Override
-*/
+public int hashCode() {
-do {
+return hash;
-Object value = cache.get(key);
+}
-if (value instanceof Reference) {
-proxyClass = (Class<?>) ((Reference) value).get();
+@Override
+public boolean equals(Object obj) {
+return this == obj ||
+obj != null &&
+obj.getClass() == KeyX.class &&
+equals(refs, ((KeyX) obj).refs);
+}
+private static boolean equals(WeakReference<Class<?>>[] refs1,
+WeakReference<Class<?>>[] refs2) {
+if (refs1.length != refs2.length) {
+return false;
+}
+for (int i = 0; i < refs1.length; i++) {
+Class<?> intf = refs1[i].get();
+if (intf == null || intf != refs2[i].get()) {
+return false;
 }
-if (proxyClass != null) {
+}
-// proxy class already generated: return it
+return true;
-return proxyClass;
+}
-} else if (value == pendingGenerationMarker) {
+}
-// proxy class being generated: wait for it
-try {
+/**
-cache.wait();
+* A function that maps an array of interfaces to an optimal key where
-} catch (InterruptedException e) {
+* Class objects representing interfaces are weakly referenced.
-/*
+*/
-* The class generation that we are waiting for should
+private static final class KeyFactory
-* take a small, bounded time, so we can safely ignore
+implements BiFunction<ClassLoader, Class<?>[], Object>
-* thread interrupts here.
+{
-*/
+@Override
-}
+public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
-continue;
+switch (interfaces.length) {
-} else {
+case 1: return new Key1(interfaces[0]); // the most frequent
-/*
+case 2: return new Key2(interfaces[0], interfaces[1]);
-* No proxy class for this list of interfaces has been
+case 0: return key0;
-* generated or is being generated, so we will go and
+default: return new KeyX(interfaces);
-* generate it now.  Mark it as pending generation.
+}
-*/
+}
-cache.put(key, pendingGenerationMarker);
+}
-break;
+/**
+* A factory function that generates, defines and returns the proxy class given
+* the ClassLoader and array of interfaces.
+*/
+private static final class ProxyClassFactory
+implements BiFunction<ClassLoader, Class<?>[], Class<?>>
+{
+// prefix for all proxy class names
+private static final String proxyClassNamePrefix = "$Proxy";
+// next number to use for generation of unique proxy class names
+private static final AtomicLong nextUniqueNumber = new AtomicLong();
+@Override
+public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
+Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
+for (Class<?> intf : interfaces) {
+/*
+* Verify that the class loader resolves the name of this
+* interface to the same Class object.
+*/
+Class<?> interfaceClass = null;
+try {
+interfaceClass = Class.forName(intf.getName(), false, loader);
+} catch (ClassNotFoundException e) {
 }
-} while (true);
+if (interfaceClass != intf) {
-}
+throw new IllegalArgumentException(
+intf + " is not visible from class loader");
-try {
+}
+/*
+* Verify that the Class object actually represents an
+* interface.
+*/
+if (!interfaceClass.isInterface()) {
+throw new IllegalArgumentException(
+interfaceClass.getName() + " is not an interface");
+}
+/*
+* Verify that this interface is not a duplicate.
+*/
+if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
+throw new IllegalArgumentException(
+"repeated interface: " + interfaceClass.getName());
+}
+}
 String proxyPkg = null;     // package to define proxy class in
 int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
 /*
 * Record the package of a non-public proxy interface so that the
 * proxy class will be defined in the same package.  Verify that
 * all non-public proxy interfaces are in the same package.
 */
-for (int i = 0; i < interfaces.length; i++) {
+for (Class<?> intf : interfaces) {
-int flags = interfaces[i].getModifiers();
+int flags = intf.getModifiers();
 if (!Modifier.isPublic(flags)) {
 accessFlags = Modifier.FINAL;
-String name = interfaces[i].getName();
+String name = intf.getName();
 int n = name.lastIndexOf('.');
 String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
 if (proxyPkg == null) {
 proxyPkg = pkg;
 } else if (!pkg.equals(proxyPkg)) {
 if (proxyPkg == null) {
 // if no non-public proxy interfaces, use com.sun.proxy package
 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
 }
-{
+/*
+* Choose a name for the proxy class to generate.
+*/
+long num = nextUniqueNumber.getAndIncrement();
+String proxyName = proxyPkg + proxyClassNamePrefix + num;
+/*
+* Generate the specified proxy class.
+*/
+byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
+proxyName, interfaces, accessFlags);
+try {
+return defineClass0(loader, proxyName,
+proxyClassFile, 0, proxyClassFile.length);
+} catch (ClassFormatError e) {
 /*
-* Choose a name for the proxy class to generate.
+* A ClassFormatError here means that (barring bugs in the
+* proxy class generation code) there was some other
+* invalid aspect of the arguments supplied to the proxy
+* class creation (such as virtual machine limitations
+* exceeded).
 */
-long num;
+throw new IllegalArgumentException(e.toString());
-synchronized (nextUniqueNumberLock) {
+}
-num = nextUniqueNumber++;
+}
-}
-String proxyName = proxyPkg + proxyClassNamePrefix + num;
-/*
-* Verify that the class loader hasn't already
-* defined a class with the chosen name.
-*/
-/*
-* Generate the specified proxy class.
-*/
-byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
-proxyName, interfaces, accessFlags);
-try {
-proxyClass = defineClass0(loader, proxyName,
-proxyClassFile, 0, proxyClassFile.length);
-} catch (ClassFormatError e) {
-/*
-* A ClassFormatError here means that (barring bugs in the
-* proxy class generation code) there was some other
-* invalid aspect of the arguments supplied to the proxy
-* class creation (such as virtual machine limitations
-* exceeded).
-*/
-throw new IllegalArgumentException(e.toString());
-}
-}
-// add to set of all generated proxy classes, for isProxyClass
-proxyClasses.put(proxyClass, null);
-} finally {
-/*
-* We must clean up the "pending generation" state of the proxy
-* class cache entry somehow.  If a proxy class was successfully
-* generated, store it in the cache (with a weak reference);
-* otherwise, remove the reserved entry.  In all cases, notify
-* all waiters on reserved entries in this cache.
-*/
-synchronized (cache) {
-if (proxyClass != null) {
-cache.put(key, new WeakReference<Class<?>>(proxyClass));
-} else {
-cache.remove(key);
-}
-cache.notifyAll();
-}
-}
-return proxyClass;
 }
 /**
 * Returns an instance of a proxy class for the specified interfaces
 * that dispatches method invocations to the specified invocation
 sm.checkPermission(new ReflectPermission("newProxyInPackage." + pkg));
 }
 }
 }
-private static Object newInstance(Constructor<?> cons, InvocationHandler h) {
-try {
-return cons.newInstance(new Object[] {h} );
-} catch (IllegalAccessException | InstantiationException e) {
-throw new InternalError(e.toString(), e);
-} catch (InvocationTargetException e) {
-Throwable t = e.getCause();
-if (t instanceof RuntimeException) {
-throw (RuntimeException) t;
-} else {
-throw new InternalError(t.toString(), t);
-}
-}
-}
 /**
 * Returns true if and only if the specified class was dynamically
 * generated to be a proxy class using the {@code getProxyClass}
 * method or the {@code newProxyInstance} method.
 *
 * @return  {@code true} if the class is a proxy class and
 *          {@code false} otherwise
 * @throws  NullPointerException if {@code cl} is {@code null}
 */
 public static boolean isProxyClass(Class<?> cl) {
-if (cl == null) {
+return Proxy.class.isAssignableFrom(cl) && proxyClassCache.containsValue(cl);
-throw new NullPointerException();
-}
-return proxyClasses.containsKey(cl);
 }
 /**
 * Returns the invocation handler for the specified proxy instance.
 *

changeset 17188	5e58e261911b
parent 16923	50bfa0defec2
child 17497	e65d73b7ae54
child 18249	aec7e8963c3e