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,
 * 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,10 @@
 import hudson.security.ACLContext;
 import hudson.security.Permission;
 import hudson.security.PermissionScope;
+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;
@@ -2392,18 +2394,14 @@ 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;
         }
 

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/util/URLClassLoader2.java

@@ -69,8 +69,23 @@ public Class<?> findLoadedClass2(String name) {
         return super.findLoadedClass(name);
     }
 
+    /**
+     * Use String.intern() to create ClassLoader/className unique lock object which can be GCed
+     *
+     * @param className
+     *         The name of the to-be-loaded class
+     *
+     * @return lock object, unique per classloader/classname combination
+     */
     @Override
     public Object getClassLoadingLock(String className) {
-        return super.getClassLoadingLock(className);
+        return new StringBuilder(128)
+                .append(getClass().getSimpleName())
+                .append("@")
+                .append(Integer.toHexString(System.identityHashCode(this)))
+                .append("-loadClassLock:")
+                .append(className)
+                .toString()
+                .intern();
     }
 }