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

Add non-locking DelegatingClassloader base implementation and use it for classloaders
which delegate functionality to other classloaders

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,6 +58,8 @@
 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.FormValidation;
@@ -106,13 +108,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 +356,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 +550,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 +672,6 @@ void considerDetachedPlugin(String shortName, String source) {
             } catch (IOException e) {
                 failedPlugins.add(new FailedPlugin(arc.getName(), e));
             }
-
         }
     }
 
@@ -973,7 +984,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 +2407,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 +2461,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();