Class ConcurrentClassLoader

  • Direct Known Subclasses:
    ModuleClassLoader

    public abstract class ConcurrentClassLoader
    extends ClassLoader
    A classloader which can delegate to multiple other classloaders without risk of deadlock. A concurrent class loader should only ever be delegated to by another concurrent class loader; however a concurrent class loader may delegate to a standard hierarchical class loader. In other words, holding a lock on another class loader while invoking a method on this class loader may cause an unexpected deadlock.
    Author:
    David M. Lloyd
    • Field Detail

      • EMPTY_ENUMERATION

        protected static final Enumeration<URL> EMPTY_ENUMERATION
        An empty enumeration, for subclasses to use if desired.
    • Constructor Detail

      • ConcurrentClassLoader

        protected ConcurrentClassLoader​(ConcurrentClassLoader parent)
        Construct a new instance with the given parent class loader, which must be a concurrent class loader, or null to create a root concurrent class loader.
        Parameters:
        parent - the parent class loader
      • ConcurrentClassLoader

        protected ConcurrentClassLoader()
        Construct a new instance, using our class loader as the parent.
    • Method Detail

      • loadClass

        public final Class<?> loadClass​(String className,
                                        boolean resolve)
                                 throws ClassNotFoundException
        Loads the class with the specified binary name.
        Overrides:
        loadClass in class ClassLoader
        Parameters:
        className - The binary name of the class
        resolve - true if the class should be linked after loading
        Returns:
        the resulting Class instance
        Throws:
        ClassNotFoundException
      • findClass

        protected Class<?> findClass​(String className,
                                     boolean exportsOnly,
                                     boolean resolve)
                              throws ClassNotFoundException
        Find a class, possibly delegating to other loader(s). This method should never synchronize across a delegation method call of any sort. The default implementation always throws ClassNotFoundException.

        If a class is to be defined by this method, it should be done via one of the atomic defineOrLoadClass methods rather than defineClass() in order to avoid spurious exceptions.

        Parameters:
        className - the class name
        exportsOnly - true if only exported classes should be considered
        resolve - true if the class should be linked after loading
        Returns:
        the class
        Throws:
        ClassNotFoundException - if the class is not found
      • defineOrLoadClass

        protected final Class<?> defineOrLoadClass​(String className,
                                                   byte[] bytes,
                                                   int off,
                                                   int len)
        Atomically define or load the named class. If the class is already defined, the existing class is returned.
        Parameters:
        className - the class name to define or load
        bytes - the bytes to use to define the class
        off - the offset into the byte array at which the class bytes begin
        len - the number of bytes in the class
        Returns:
        the class
      • defineOrLoadClass

        protected final Class<?> defineOrLoadClass​(String className,
                                                   byte[] bytes,
                                                   int off,
                                                   int len,
                                                   ProtectionDomain protectionDomain)
        Atomically define or load the named class. If the class is already defined, the existing class is returned.
        Parameters:
        className - the class name to define or load
        bytes - the bytes to use to define the class
        off - the offset into the byte array at which the class bytes begin
        len - the number of bytes in the class
        protectionDomain - the protection domain for the defined class
        Returns:
        the class
      • getResource

        public final URL getResource​(String name)
        Finds the resource with the given name. The name of a resource is a '/'-separated path name that identifies the resource. If the resource name starts with "java/" then the parent class loader is used. Otherwise, this method delegates to findResource(String, boolean).
        Overrides:
        getResource in class ClassLoader
        Parameters:
        name - the name of the resource
        Returns:
        the resource URL, or null if no such resource exists or the invoker does not have adequate permission to access it
      • findResource

        protected URL findResource​(String name,
                                   boolean exportsOnly)
        Find the resource with the given name and exported status.
        Parameters:
        name - the resource name
        exportsOnly - true to consider only exported resources or false to consider all resources
        Returns:
        the resource URL
        See Also:
        getResource(String)
      • findResources

        protected Enumeration<URL> findResources​(String name,
                                                 boolean exportsOnly)
                                          throws IOException
        Finds the resources with the given name and exported status.
        Parameters:
        name - the resource name
        exportsOnly - true to consider only exported resources or false to consider all resources
        Returns:
        the resource enumeration
        Throws:
        IOException - if an I/O error occurs
        See Also:
        getResources(String)
      • findResourceAsStream

        protected InputStream findResourceAsStream​(String name,
                                                   boolean exportsOnly)
        Finds the resource with the given name and exported status, returning the resource content as a stream.
        Parameters:
        name - the resource name
        exportsOnly - true to consider only exported resources or false to consider all resources
        Returns:
        the resource stream, or null if the resource is not found
      • getResourceAsStream

        public final InputStream getResourceAsStream​(String name)
        Returns an input stream for reading the specified resource. If the resource starts with "java/", then this method delegates to the parent class loader. Otherwise, this method delegates to findResourceAsStream(String, boolean).
        Overrides:
        getResourceAsStream in class ClassLoader
        Parameters:
        name - the resource name
        Returns:
        the resource stream, or null if the resource is not found
      • getPackage

        protected final Package getPackage​(String name)
        Load a package which is visible to this class loader.
        Overrides:
        getPackage in class ClassLoader
        Parameters:
        name - the package name
        Returns:
        the package, or null if no such package is visible to this class loader
      • getPackageByName

        protected Package getPackageByName​(String name)
        Perform the actual work to load a package which is visible to this class loader. By default, uses a simple parent-first delegation strategy.
        Parameters:
        name - the package name
        Returns:
        the package, or null if no such package is visible to this class loader
      • getPackages

        protected Package[] getPackages()
        Get all defined packages which are visible to this class loader.
        Overrides:
        getPackages in class ClassLoader
        Returns:
        the packages
      • findLoadedPackage

        protected final Package findLoadedPackage​(String name)
        Load a package from this class loader only.
        Parameters:
        name - the package name
        Returns:
        the package or null if no such package is defined by this class loader
      • definePackage

        protected Package definePackage​(String name,
                                        String specTitle,
                                        String specVersion,
                                        String specVendor,
                                        String implTitle,
                                        String implVersion,
                                        String implVendor,
                                        URL sealBase)
                                 throws IllegalArgumentException
        Defines a package by name in this ConcurrentClassLoader. If the package was already defined, the existing package is returned instead.
        Overrides:
        definePackage in class ClassLoader
        Parameters:
        name - the package name
        specTitle - the specification title
        specVersion - the specification version
        specVendor - the specification vendor
        implTitle - the implementation title
        implVersion - the implementation version
        implVendor - the implementation vendor
        sealBase - if not null, then this package is sealed with respect to the given code source URL
        Returns:
        the newly defined package, or the existing one if one was already defined
        Throws:
        IllegalArgumentException