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

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/PluginFirstClassLoader2.java

@@ -21,10 +21,6 @@
  */
 @Restricted(NoExternalUse.class)
 public class PluginFirstClassLoader2 extends URLClassLoader2 {
-    static {
-        registerAsParallelCapable();
-    }
-
 
     public PluginFirstClassLoader2(String name, @NonNull URL[] urls, @NonNull ClassLoader parent) {
         super(name, Objects.requireNonNull(urls), Objects.requireNonNull(parent));

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

@@ -60,6 +60,7 @@
 import hudson.security.PermissionScope;
 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;
@@ -2396,30 +2397,32 @@ 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());
             this.activePlugins = activePlugins;
         }
 
         @Override
         protected Class<?> findClass(String name) throws ClassNotFoundException {
-            if (name.startsWith("SimpleTemplateScript")) { // cf. groovy.text.SimpleTemplateEngine
+            if (name.startsWith("SimpleTemplateScript") || // cf. groovy.text.SimpleTemplateEngine
+                    name.startsWith("groovy.tmp.")) {
                 throw new ClassNotFoundException("ignoring " + name);
             }
             return loaded.computeIfAbsent(name, this::computeValue).orElseThrow(() -> new ClassNotFoundException(name));
         }
 
         private Optional<Class<?>> computeValue(String name) {
+            if (!name.equals("java.lang.$JaCoCo") && // Add support for loading of JaCoCo dynamic instrumentation classes
+                    getResource(name.replace('.', '/') + ".class") == null) {
+                return Optional.empty();
+            }
+
             for (PluginWrapper p : activePlugins) {
                 try {
                     if (FAST_LOOKUP) {

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

@@ -0,0 +1,54 @@
+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);
+    }
+
+    /**
+     * 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 = Class.forName(name, resolve, getParent());
+            }
+        } 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);
+        }
+
+        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/util/URLClassLoader2.java

@@ -12,11 +12,6 @@
  */
 @Restricted(NoExternalUse.class)
 public class URLClassLoader2 extends URLClassLoader implements JenkinsClassLoader {
-
-    static {
-        registerAsParallelCapable();
-    }
-
     /**
      * @deprecated use {@link URLClassLoader2#URLClassLoader2(String, URL[])}
      */