Class ConcurrentClassLoader

java.lang.Object
java.lang.ClassLoader
org.jboss.modules.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.

  • Field Details

  • Constructor Details

    • 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 Details

    • loadClass

      public final Class<?> loadClass(String className) throws ClassNotFoundException
      Loads the class with the specified binary name. Equivalent to calling loadClass(className, false).
      Overrides:
      loadClass in class ClassLoader
      Parameters:
      className - The binary name of the class
      Returns:
      the resulting Class instance
      Throws:
      ClassNotFoundException - if the class was not found

    • 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

    • loadExportedClass

      public final Class<?> loadExportedClass(String className) throws ClassNotFoundException
      Same as loadClass(String), except only exported classes will be considered.
      Parameters:
      className - the class name
      Returns:
      the class
      Throws:
      ClassNotFoundException - if the class isn't found

    • loadExportedClass

      public final Class<?> loadExportedClass(String className, boolean resolve) throws ClassNotFoundException
      Same as loadClass(String,boolean), except only exported classes will be considered.
      Parameters:
      className - the class name
      resolve - true if the class should be linked after loading
      Returns:
      the class
      Throws:
      ClassNotFoundException - if the class isn't found

    • 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

    • findClass

      protected final Class<?> findClass(String className) throws ClassNotFoundException
      Implementation of ClassLoader.findClass(String).
      Overrides:
      findClass in class ClassLoader
      Parameters:
      className - the class name
      Returns:
      the result of findClass(className, false, false)
      Throws:
      ClassNotFoundException

    • 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

    • getResources

      public final Enumeration<URL> getResources(String name) throws IOException
      Finds all available resources with the given name.
      Overrides:
      getResources in class ClassLoader
      Parameters:
      name - the resource name
      Returns:
      an enumeration over all the resource URLs; if no resources could be found, the enumeration will be empty
      Throws:
      IOException - if an I/O error occurs
      See Also:

    • 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:

    • findResource

      protected final URL findResource(String name)
      Never used. ClassLoader.getResource(String) and related methods can cause a loop condition when this method is implemented; use findResource(String, boolean) instead.
      Overrides:
      findResource in class ClassLoader
      Parameters:
      name - ignored
      Returns:
      null always

    • 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:

    • findResources

      protected final Enumeration<URL> findResources(String name)
      Never used. ClassLoader.getResources(String) and related methods can cause a loop condition when this method is implemented; use findResources(String, boolean) instead. By default, returns an empty enumeration.
      Overrides:
      findResources in class ClassLoader
      Parameters:
      name - ignored
      Returns:
      an empty enumeration

    • 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

    • performLoadClass

      private Class<?> performLoadClass(String className, boolean exportsOnly, boolean resolve) throws ClassNotFoundException
      Perform a class load operation. If the class is in the package or a subpackage of a package in the system packages list, the parent class loader is used to load the class. Otherwise, this method checks to see if the class loader object is locked; if so, it unlocks it and submits the request to the class loader thread. Otherwise, it will load the class itself by delegating to findClass(String, boolean, boolean).
      Parameters:
      className - the class name
      exportsOnly - true to consider only exported resources or false to consider all resources
      resolve - true to resolve the loaded class
      Returns:
      the class returned by findClass(String, boolean, boolean)
      Throws:
      ClassNotFoundException - if findClass(String, boolean, boolean) throws this exception

    • performLoadClassUnchecked

      private Class<?> performLoadClassUnchecked(String className, boolean exportsOnly, boolean resolve) throws ClassNotFoundException
      Throws:
      ClassNotFoundException

    • 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