Changeset 1959

Timestamp:

2011-12-22 14:42:36 (5 months ago)

Author:

bruno

Message:

Introduce a ClassLoader? cache (to be enabled explicitly using a system property) which is useful when you restart the same Kauri instance frequently in the same JVM (we do this in Lily's test framework).

File:

• trunk/core/kauri-runtime/src/main/java/org/kauriproject/runtime/classloading/ClassLoaderBuilder.java (modified) (3 diffs)

trunk/core/kauri-runtime/src/main/java/org/kauriproject/runtime/classloading/ClassLoaderBuilder.java

@@ -16 +16 @@
 package org.kauriproject.runtime.classloading;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.kauriproject.runtime.repository.ArtifactRepository;
 import org.kauriproject.runtime.repository.ArtifactNotFoundException;
 
+import java.util.HashMap;
 import java.util.List;
 import java.util.ArrayList;
@@ -25 +28 @@
 import java.net.MalformedURLException;
 import java.io.File;
+import java.util.Map;
 
 public class ClassLoaderBuilder {
-    public static ClassLoader build(List<ClasspathEntry> classpathEntries, ClassLoader parentClassLoader,
+    private static Map<String, ClassLoader> classLoaderCache;
+    private static boolean classLoaderCacheEnabled = true;
+    static {
+        classLoaderCacheEnabled = System.getProperty("kauri.cacheclassloaders") != null;
+        if (classLoaderCacheEnabled) {
+            classLoaderCache = new HashMap<String, ClassLoader>();
+        }
+    }
+    
+    public static synchronized ClassLoader build(List<ClasspathEntry> classpathEntries, ClassLoader parentClassLoader,
+            ArtifactRepository repository) throws ArtifactNotFoundException, MalformedURLException {
+        
+        if (classLoaderCacheEnabled) {
+            //
+            // About the ClassLoader cache:
+            //  The ClassLoader cache was introduced to handle leaks in the 'Perm Gen' and 'Code Cache'
+            //  JVM memory spaces when repeatedly restarting Kauri within the same JVM. In such cases,
+            //  on each restart Kauri would construct new class loaders, hence the classes loaded through
+            //  them would be new and would stress those JVM memory spaces.
+            //
+            //  The solution here is good enough for what it is intended to do (restarting the same Kauri
+            //  app, unchanged, many times). There is no cache cleaning and the cache key calculation
+            //  is not perfect, so if you would enable the cache when starting a wide variety of Kauri
+            //  apps within one VM or for reloading changed Kauri apps, it could be problematic.
+            //
+            StringBuilder cacheKeyBuilder = new StringBuilder(2000);
+            for (ClasspathEntry entry : classpathEntries) {
+                cacheKeyBuilder.append(entry.getArtifactRef()).append("\u2603" /* unicode snowman as separator */);
+            }
+            
+            // Add some identification of the parent class loader
+            if (parentClassLoader instanceof URLClassLoader) {
+                for (URL url : ((URLClassLoader)parentClassLoader).getURLs()) {
+                    cacheKeyBuilder.append(url.toString());
+                }
+            }
+            
+            String cacheKey = cacheKeyBuilder.toString();
+            
+            ClassLoader classLoader = classLoaderCache.get(cacheKey);
+            if (classLoader == null) {
+                Log log = LogFactory.getLog(ClassLoaderBuilder.class);
+                log.debug("Creating and caching a new classloader");
+                classLoader = create(classpathEntries, parentClassLoader, repository);
+                classLoaderCache.put(cacheKey, classLoader);
+            } else if (classLoader.getParent() != parentClassLoader) {
+                Log log = LogFactory.getLog(ClassLoaderBuilder.class);
+                log.error("Kauri ClassLoader cache: parentClassLoader of cache ClassLoader is different" +
+                        " from the specified one. Returning the cached one anyway.");
+            }
+            
+            return classLoader;            
+        } else {        
+            return create(classpathEntries, parentClassLoader, repository);
+        }
+    }
+    
+    private static ClassLoader create(List<ClasspathEntry> classpathEntries, ClassLoader parentClassLoader,
             ArtifactRepository repository) throws ArtifactNotFoundException, MalformedURLException {
         List<URL> classpath = new ArrayList<URL>();
@@ -36 +97 @@
         }
 
-        return new URLClassLoader(classpath.toArray(new URL[classpath.size()]), parentClassLoader);
+        return new URLClassLoader(classpath.toArray(new URL[classpath.size()]), parentClassLoader);        
     }
 }