JENKINS-75675: Refactor classloader logic in order to reduce memory consumption

Override URLClassloader2.getClassLoadingLock to use lock objects that can be GCed when not needed,
Wrap WebAppClassLoader with CheckingExistenceClassLoader to avoid missing loadClass() calls not to crate unnecessary persistent lock object,
Refactor delegating classloaders not to use locking:
 * DelegatingClassloader - non-locking base implementation and use it for classloaders
   which delegate functionality to other classloaders,
 * CachingClassloader - for caching class loading result, useful if loadClass operation is heavy,
 * CheckingExistenceClassLoader - check that class exists before loadClass() calls.

Author: Dmytro Ukhlov

core/src/main/java/hudson/ClassicPluginStrategy.java

@@ -33,6 +33,7 @@
 import hudson.model.Hudson;
 import hudson.util.CyclicGraphDetector;
 import hudson.util.CyclicGraphDetector.CycleDetectedException;
+import hudson.util.DelegatingClassLoader;
 import hudson.util.IOUtils;
 import hudson.util.MaskingClassLoader;
 import java.io.File;
@@ -559,7 +560,7 @@ private static void unzipExceptClasses(File archive, File destDir, Project prj)
     /**
      * Used to load classes from dependency plugins.
      */
-    static final class DependencyClassLoader extends ClassLoader {
+    static final class DependencyClassLoader extends DelegatingClassLoader {
         /**
          * This classloader is created for this plugin. Useful during debugging.
          */
@@ -574,10 +575,6 @@ static final class DependencyClassLoader extends ClassLoader {
          */
         private volatile List<PluginWrapper> transitiveDependencies;
 
-        static {
-            registerAsParallelCapable();
-        }
-
         DependencyClassLoader(ClassLoader parent, File archive, List<Dependency> dependencies, PluginManager pluginManager) {
             super("dependency ClassLoader for " + archive.getPath(), parent);
             this._for = archive;

core/src/main/java/hudson/PluginManager.java

@@ -58,8 +58,11 @@
 import hudson.security.ACLContext;
 import hudson.security.Permission;
 import hudson.security.PermissionScope;
+import hudson.util.CachingClassLoader;
+import hudson.util.CheckingExistenceClassLoader;
 import hudson.util.CyclicGraphDetector;
 import hudson.util.CyclicGraphDetector.CycleDetectedException;
+import hudson.util.DelegatingClassLoader;
 import hudson.util.FormValidation;
 import hudson.util.PersistedList;
 import hudson.util.Retrier;
@@ -106,13 +109,11 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
-import java.util.Optional;
 import java.util.ServiceLoader;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Future;
 import java.util.function.Supplier;
@@ -356,7 +357,19 @@ PluginManager doCreate(@NonNull Class<? extends PluginManager> klass,
      */
     // implementation is minimal --- just enough to run XStream
     // and load plugin-contributed classes.
-    public final ClassLoader uberClassLoader = new UberClassLoader(activePlugins);
+    public final ClassLoader uberClassLoader = new CachingClassLoader("Caching UberClassLoader",
+            new UberClassLoader(activePlugins)) {
+        @Override
+        protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+            // basic check before use cache-based loading
+            if (name.startsWith("SimpleTemplateScript") || // cf. groovy.text.SimpleTemplateEngine
+                    name.startsWith("groovy.tmp.")) {
+                throw new ClassNotFoundException("ignoring " + name);
+            }
+
+            return super.loadClass(name, resolve);
+        }
+    };
 
     /**
      * Once plugin is uploaded, this flag becomes true.
@@ -538,7 +551,7 @@ protected void reactOnCycle(PluginWrapper q, List<PluginWrapper> cycle) {
                                         for (PluginWrapper p : cgd.getSorted()) {
                                             if (p.isActive()) {
                                                 activePlugins.add(p);
-                                                ((UberClassLoader) uberClassLoader).clearCacheMisses();
+                                                ((CachingClassLoader) uberClassLoader).clearCacheMisses();
                                             }
                                         }
                                     } catch (CycleDetectedException e) { // TODO this should be impossible, since we override reactOnCycle to not throw the exception
@@ -660,7 +673,6 @@ void considerDetachedPlugin(String shortName, String source) {
             } catch (IOException e) {
                 failedPlugins.add(new FailedPlugin(arc.getName(), e));
             }
-
         }
     }
 
@@ -973,7 +985,7 @@ public void dynamicLoad(File arc, boolean removeExisting, @CheckForNull List<Plu
             plugins.add(p);
             if (p.isActive()) {
                 activePlugins.add(p);
-                ((UberClassLoader) uberClassLoader).clearCacheMisses();
+                ((CachingClassLoader) uberClassLoader).clearCacheMisses();
             }
 
             // TODO antimodular; perhaps should have a PluginListener to complement ExtensionListListener?
@@ -2396,43 +2408,29 @@ public <T> T of(String key, Class<T> type, Supplier<T> func) {
     /**
      * {@link ClassLoader} that can see all plugins.
      */
-    public static final class UberClassLoader extends ClassLoader {
+    public static final class UberClassLoader extends DelegatingClassLoader {
         private final List<PluginWrapper> activePlugins;
 
-        /** Cache of loaded, or known to be unloadable, classes. */
-        private final ConcurrentMap<String, Optional<Class<?>>> loaded = new ConcurrentHashMap<>();
-
-        static {
-            registerAsParallelCapable();
-        }
-
         public UberClassLoader(List<PluginWrapper> activePlugins) {
-            super("UberClassLoader", PluginManager.class.getClassLoader());
+            super("UberClassLoader", new CheckingExistenceClassLoader(PluginManager.class.getClassLoader()));
             this.activePlugins = activePlugins;
         }
 
         @Override
         protected Class<?> findClass(String name) throws ClassNotFoundException {
-            if (name.startsWith("SimpleTemplateScript")) { // cf. groovy.text.SimpleTemplateEngine
-                throw new ClassNotFoundException("ignoring " + name);
-            }
-            return loaded.computeIfAbsent(name, this::computeValue).orElseThrow(() -> new ClassNotFoundException(name));
-        }
-
-        private Optional<Class<?>> computeValue(String name) {
             for (PluginWrapper p : activePlugins) {
                 try {
                     if (FAST_LOOKUP) {
-                        return Optional.of(ClassLoaderReflectionToolkit.loadClass(p.classLoader, name));
+                        return ClassLoaderReflectionToolkit.loadClass(p.classLoader, name);
                     } else {
-                        return Optional.of(p.classLoader.loadClass(name));
+                        return p.classLoader.loadClass(name);
                     }
                 } catch (ClassNotFoundException e) {
                     // Not found. Try the next class loader.
                 }
             }
-            // Not found in any of the class loaders. Delegate.
-            return Optional.empty();
+
+            throw new ClassNotFoundException(name);
         }
 
         @Override
@@ -2464,31 +2462,28 @@ protected Enumeration<URL> findResources(String name) throws IOException {
             return Collections.enumeration(resources);
         }
 
-        void clearCacheMisses() {
-            loaded.values().removeIf(Optional::isEmpty);
-        }
 
         @Override
         public String toString() {
             // only for debugging purpose
             return "classLoader " +  getClass().getName();
         }
+    }
 
-        // TODO Remove this once we require post 2024-07 remoting minimum version and deleted ClassLoaderProxy#fetchJar(URL)
-        @SuppressFBWarnings(
-                value = "DMI_COLLECTION_OF_URLS",
-                justification = "All URLs point to local files, so no DNS lookup.")
-        @Restricted(NoExternalUse.class)
-        public boolean isPluginJar(URL jarUrl) {
-            for (PluginWrapper plugin : activePlugins) {
-                if (plugin.classLoader instanceof URLClassLoader) {
-                    if (Set.of(((URLClassLoader) plugin.classLoader).getURLs()).contains(jarUrl)) {
-                        return true;
-                    }
+    // TODO Remove this once we require post 2024-07 remoting minimum version and deleted ClassLoaderProxy#fetchJar(URL)
+    @SuppressFBWarnings(
+            value = "DMI_COLLECTION_OF_URLS",
+            justification = "All URLs point to local files, so no DNS lookup.")
+    @Restricted(NoExternalUse.class)
+    public boolean isPluginJar(URL jarUrl) {
+        for (PluginWrapper plugin : activePlugins) {
+            if (plugin.classLoader instanceof URLClassLoader) {
+                if (Set.of(((URLClassLoader) plugin.classLoader).getURLs()).contains(jarUrl)) {
+                    return true;
                 }
             }
-            return false;
         }
+        return false;
     }
 
     @SuppressFBWarnings(value = "MS_SHOULD_BE_FINAL", justification = "for script console")

core/src/main/java/hudson/util/CachingClassLoader.java

@@ -0,0 +1,66 @@
+package hudson.util;
+
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ *
+ * ClassLoader with internal caching of class loading results.
+ *
+ * <p>
+ * Caches both successful and failed class lookups to avoid redundant delegation
+ * and repeated class resolution attempts. Designed for performance optimization
+ * in systems that repeatedly query class presence (e.g., plugin environments,
+ * reflective loading, optional dependencies).
+ * </p>
+ *
+ * Useful for classloaders that have heavy-weight loadClass() implementations
+ *
+ * @author Dmytro Ukhlov
+ */
+public class CachingClassLoader extends DelegatingClassLoader {
+    private final ConcurrentHashMap<String, Object> loaded = new ConcurrentHashMap<>();
+
+    public CachingClassLoader(String name, ClassLoader parent) {
+        super(name, parent);
+    }
+
+    @Override
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        Object classOrEmpty = loaded.computeIfAbsent(name, key -> {
+            try {
+                return doLoadClass(name);
+            } catch (ClassNotFoundException e) {
+                // Not found.
+                return Optional.empty();
+            }
+        });
+
+        if (classOrEmpty == Optional.empty()) {
+            throw new ClassNotFoundException(name);
+        }
+
+        Class<?> clazz = (Class<?>) classOrEmpty;
+        if (resolve) {
+            resolveClass(clazz);
+        }
+        return clazz;
+    }
+
+    /**
+     * Do effective class loading
+     *
+     * @param name class name to load
+     *
+     * @return loaded class
+     *
+     * @throws ClassNotFoundException if class not found
+     */
+    protected Class<?> doLoadClass(String name) throws ClassNotFoundException {
+        return super.loadClass(name, false);
+    }
+
+    public void clearCacheMisses() {
+        loaded.values().removeIf(v -> v == Optional.empty());
+    }
+}

core/src/main/java/hudson/util/CheckingExistenceClassLoader.java

@@ -0,0 +1,36 @@
+package hudson.util;
+
+/**
+ * A class loader that verifies the existence of a class resource before attempting to load the class.
+ * <p>
+ * This implementation overrides {@link #loadClass(String, boolean)} and uses {@link #getResource(String)}
+ * to check whether the corresponding <code>.class</code> file is available in the classpath.
+ * If the resource is not found, a {@link ClassNotFoundException} is thrown immediately.
+ * </p>
+ *
+ * <p>This approach can be useful in environments where conditional class availability
+ * must be verified without triggering side effects from the loading process.</p>
+ *
+ * @see ClassLoader
+ * @see #getResource(String)
+ */
+public class CheckingExistenceClassLoader extends DelegatingClassLoader {
+
+    public CheckingExistenceClassLoader(String name, ClassLoader parent) {
+        super(name, parent);
+    }
+
+    public CheckingExistenceClassLoader(ClassLoader parent) {
+        super(parent);
+    }
+
+    @Override
+    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+        if (getResource(name.replace('.', '/') + ".class") == null &&
+                !name.equals("java.lang.$JaCoCo")) { // Add support for loading of JaCoCo dynamic instrumentation classes
+            throw new ClassNotFoundException(name);
+        }
+
+        return super.loadClass(name, resolve);
+    }
+}

core/src/main/java/hudson/util/DelegatingClassLoader.java

@@ -0,0 +1,61 @@
+package hudson.util;
+
+/**
+ * A {@link ClassLoader} that does not define any classes itself but delegates class loading
+ * to other class loaders. It first attempts to load classes via its {@code getParent()} class loader,
+ * then falls back to {@code findClass} to allow for custom delegation logic.
+ * <p>
+ * This class can also serve as the parent class loader for other class loaders that follow
+ * the standard delegation model.
+ *
+ * @author Dmytro Ukhlov
+ */
+public class DelegatingClassLoader extends ClassLoader {
+    protected DelegatingClassLoader(String name, ClassLoader parent) {
+        super(name, parent);
+    }
+
+    public DelegatingClassLoader(ClassLoader parent) {
+        super(parent);
+    }
+
+    /**
+     * Overrides base implementation to skip unnecessary synchronization
+     *
+     * @param   name
+     *          The <a href="#binary-name">binary name</a> of the class
+     *
+     * @param   resolve
+     *          If {@code true} then resolve the class
+     *
+     * @return  The resulting {@code Class} object
+     *
+     * @throws  ClassNotFoundException
+     *          If the class could not be found
+     */
+    @Override
+    protected Class<?> loadClass(String name, boolean resolve)
+            throws ClassNotFoundException
+    {
+        Class<?> c = null;
+        try {
+            if (getParent() != null) {
+                c = getParent().loadClass(name);
+            }
+        } catch (ClassNotFoundException e) {
+            // ClassNotFoundException thrown if class not found
+            // from the non-null parent class loader
+        }
+
+        if (c == null) {
+            // If still not found, then invoke findClass in order
+            // to find the class.
+            c = findClass(name);
+        }
+
+        if (resolve) {
+            resolveClass(c);
+        }
+        return c;
+    }
+}

core/src/main/java/hudson/util/MaskingClassLoader.java

@@ -42,18 +42,14 @@
  *
  * @author Kohsuke Kawaguchi
  */
-public class MaskingClassLoader extends ClassLoader {
+public class MaskingClassLoader extends DelegatingClassLoader {
     /**
      * Prefix of the packages that should be hidden.
      */
     private final List<String> masksClasses;
 
     private final List<String> masksResources;
 
-    static {
-        registerAsParallelCapable();
-    }
-
     public MaskingClassLoader(ClassLoader parent, String... masks) {
         this(parent, Arrays.asList(masks));
     }

core/src/main/java/jenkins/security/s2m/JarURLValidatorImpl.java

@@ -83,12 +83,10 @@ public void validate(URL url) throws IOException {
             value = "DMI_COLLECTION_OF_URLS",
             justification = "All URLs point to local files, so no DNS lookup.")
     private static boolean isAllowedJar(URL url) {
-        final ClassLoader classLoader = Jenkins.get().getPluginManager().uberClassLoader;
-        if (classLoader instanceof PluginManager.UberClassLoader uberClassLoader) {
-            if (uberClassLoader.isPluginJar(url)) {
-                LOGGER.log(Level.FINER, () -> "Determined to be plugin jar: " + url);
-                return true;
-            }
+        final PluginManager pluginManager = Jenkins.get().getPluginManager();
+        if (pluginManager.isPluginJar(url)) {
+            LOGGER.log(Level.FINER, () -> "Determined to be plugin jar: " + url);
+            return true;
         }
 
         final ClassLoader coreClassLoader = Jenkins.class.getClassLoader();