dilema de Java classLoader con jaros bloqueados

Question

Estaba jugando con classLoaders en Java y noté algo extraño. Si un classLoader carga una clase desde un jar, este jar está bloqueado indefinidamente incluso si deshaces tu classLoader.

En el siguiente ejemplo, el contenedor contiene una clase llamada HelloWorld. Lo que hago es tratar de cargar la clase contenida en el jar a través de un classLoader que agrega el jar dinámicamente. Si configura skip en true y no llama al Class.forName, puede eliminar el jar pero si no se salta e incluso si desvincula el classLoader (classLoader = null), el jar no se puede eliminar hasta que salga la JVM.

¿Por qué es eso?

PS: Estoy usando Java 6 y el código es muy detallado para propósitos de prueba

package loader; 

import java.io.File; 
import java.io.FileInputStream; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.net.MalformedURLException; 
import java.net.URL; 
import java.net.URLClassLoader; 

public class TestClassLoader { 

    private URLClassLoader classLoader; 

    public TestClassLoader() throws MalformedURLException, IOException { 
     System.out.println("Copying jar"); 
     if (copyJar()) { 
      System.out.println("Copying SUCCESS"); 
      performFirstCheck(); 
     } else { 
      System.out.println("Copying FAILED"); 
     } 
    } 

    public static void main(String[] args) throws IOException { 
     System.out.println("Test started"); 
     TestClassLoader testClassLoader = new TestClassLoader(); 
     System.out.println("Bye!"); 
    } 

    public void performFirstCheck() throws IOException { 
     System.out.println("Checking class HelloWorld does not exist"); 
     if (!checkClassFound(TestClassLoader.class.getClassLoader(), false)) { 
      System.out.println("Deleting jar"); 
      deleteJar(); 
      System.out.println("First Check SUCCESS"); 
      performSecondCheck(); 
     } else { 
      System.out.println("First Check FAILED"); 
     } 
    } 

    private void performSecondCheck() throws IOException { 
     System.out.println("Copying jar"); 
     if (copyJar()) { 
      System.out.println("Copying SUCCESS"); 
      createClassLoaderAndCheck(); 
     } else { 
      System.out.println("Copying FAILED"); 
     } 
    } 

    private void createClassLoaderAndCheck() throws MalformedURLException { 
     System.out.println("Creating classLoader"); 
     createClassLoader(); 
     System.out.println("Checking class HelloWorld exist"); 
     if (checkClassFound(classLoader, true)) { 
      System.out.println("Second Check SUCCESS"); 
        classLoader = null; 
      System.out.println("Deleting jar"); 
      if (deleteJar()) { 
       System.out.println("Deleting SUCCESS"); 
      } else { 
       System.out.println("Deleting FAILED"); 
      } 
     } else { 
      System.out.println("Second Check FAILED"); 
     } 
    } 

    public void createClassLoader() throws MalformedURLException { 
     URL[] urls = new URL[1]; 
     File classFile = new File("C:\\Users\\Adel\\Desktop\\classes.jar"); 
     urls[0] = classFile.toURI().toURL(); 
     classLoader = new URLClassLoader(urls); 
    } 

    public boolean checkClassFound(ClassLoader classLoader, boolean skip) { 
     if (skip) { 
      System.out.println("Skiping class loading"); 
      return true; 
     } else { 
      try { 
       Class.forName("HelloWorld", true, classLoader); 
       return true; 
      } catch (ClassNotFoundException e) { 
       return false; 
      } 
     } 
    } 

    public URLClassLoader getClassLoader() { 
     return classLoader; 
    } 

    public boolean copyJar() throws IOException { 
     File sourceJar = new File("C:\\Users\\Adel\\Desktop\\Folder\\classes.jar"); 
     File destJar = new File("C:\\Users\\Adel\\Desktop\\classes.jar"); 
     if (destJar.exists()) { 
      return false; 
     } else { 
      FileInputStream finput = new FileInputStream(sourceJar); 
      FileOutputStream foutput = new FileOutputStream(destJar); 
      byte[] buf = new byte[1024]; 
      int len; 
      while ((len = finput.read(buf)) > 0) { 
       foutput.write(buf, 0, len); 
      } 
      finput.close(); 
      foutput.close(); 
      return true; 
     } 
    } 

    public boolean deleteJar() { 
     File destJar = new File("C:\\Users\\Adel\\Desktop\\classes.jar"); 
     return destJar.delete(); 
    } 

} 

Answer 1

He encontrado una respuesta y una solución.

Basado en este article y este sorprendente relacionado article, es un mal hábito utilizar Class.forName(className, true, classLoader) porque mantiene la clase en la memoria caché en la memoria indefinidamente.

La solución fue utilizar classLoader.loadClass(clasName) lugar, a continuación, una vez terminado, el classLoader Deshacer referencia y llamar al recolector de basura usando:

classLoader = null; 
System.gc(); 

Esperamos que esto ayude a otros! :)

Antecedentes:

Mi proyecto era un Complexe uno: tuvimos un servidor GWT actúa como cliente RMI a otro servidor. Entonces, para crear instancias, GWT necesitaba descargar las clases del servidor y cargarlas. Más tarde, GWT volvería a enviar la instancia al servidor para persistir en la base de datos usando Hibernate. Con el fin de admitir la implementación en caliente, optamos por la carga de clase dinámica donde un usuario cargaría un jar y notificaría al servidor quién cargaría las clases y presentarlas como disponibles para el servidor GWT

Answer 2

En Java 7 URLClassLoader tiene un método que soluciona este #close().