内存泄漏 - 从Class类加载器说起开发者社区

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

内存泄漏 - 从Class类加载器说起

package com.test;  
public class StaticCls{  
public static void main(String[] args){  
    OuterCls.InnerCls.test();  
class OuterCls{  
  public static class InnerCls{  
     public static void test(){  
        System.out.println("InnerCls");  
}

package com.test;  
public class StaticCls {  
   public static void main(String[] args) { 
   OuterCls.InnerCls.test();  
class OuterCls {  
  public static class InnerCls {  
    public static void test() {  
      System.out.println("InnerCls");  
}

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
<%@page language="java" contentType="text/html; charset=GB18030" pageEncoding="GB18030"%>  
<html><head>  
<title>dump</title>  
<meta http-equiv="Content-Type" content="text/html; charset=GB18030"></head>  
<h2> 产生HeapDump 和 JavaCore</h2>  
<%String heapdumpCmd = request.getParameter("heapdump");  
if(heapdumpCmd!=null) com.ibm.jvm.Dump.HeapDump();  
String javacoreCmd = request.getParameter("javacore");  
if(javacoreCmd != null) com.ibm.jvm.Dump.JavaDump();  
String gcCmd = request.getParameter("gc");  
if(gcCmd != null) System.gc();%>  
<form action="dump.jsp">  
<input type="submit" name="gc" value="GarbageCollection">  
<input type="submit" name="heapdump" value="CreateHeapDump">  
<input type="submit" name="javacore" value="CreateJavaCore"></form>  
</body>  
</html>

public class ClassLoadBugServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet{  
    private static byte[] testByteArray = newbyte[2024000];  
    public ClassLoadBugServlet(){  
        super();  
    protected void doGet(HttpServletRequest request,HttpServletResponse response) throwsServletException,IOException{  
        perform(request,response);  
    protected void doPost(HttpServletRequest request,HttpServletResponse response) throwsServletException,IOException{  
        perform(request,response);  
    private void perform(HttpServletRequest request,HttpServletResponse response) throwsIOException{  
        StaticClasss c = newStaticClass();  
        response.getOutputStream().print(sc.test());  
        System.out.println(sc.test());  
}

public class StaticClass{  
    privates tatic byte[] testByteArray = new byte[2024000];  
    public String test(){  
        return "TestClassLoader";  
}

public class StaticClass {  
 private static byte[] testByteArray = new byte[2024000];  
 public String test(){ return "Test Class Loader"; }  
}

public class ClassLoaderTestServlet extends javax.servlet.http.HttpServlet implements javax.servlet.Servlet{  
    public ClassLoaderTestServlet(){super();}  
    protected void doGet(HttpServletRequest request,HttpServletResponse response) throwsServletException,IOException{  
        perform(request,response);  
    protected void doPost(HttpServletRequest request,HttpServletResponse response) throwsServletException,IOException{  
        perform(request,response);  
    private void perform(HttpServletRequest request,HttpServletResponse response) throwsIOException{  
        StaticClasss c = (StaticClass)getClassPathApplicationContext().getBean("staticClass");  
        response.getOutputStream().print(sc.test());  
        System.out.println(sc.test());  
    private ApplicationContext getWebApplicationContext(){  
        WebApplicationContextwac=null;  
        wac=(WebApplicationContext)getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
        return wac;  
    private ApplicationContext getClassPathApplicationContext(){  
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/serviceContext.xml");  
        return context;  
}

public class ClassLoaderTestServlet extends javax.servlet.http.HttpServlet  
implements javax.servlet.Servlet {  
 public ClassLoaderTestServlet() { super(); }  
 protected void doGet(HttpServletRequest request,  
HttpServletResponse response) throws ServletException, IOException  
{ perform(request, response); }  
 protected void doPost(HttpServletRequest request,  
HttpServletResponse response) throws ServletException, IOException  
{ perform(request, response); }  
 private void perform(HttpServletRequest request,  
HttpServletResponse response) throws IOException {  
 StaticClass sc = (StaticClass)  
getClassPathApplicationContext().getBean("staticClass");  
 response.getOutputStream().print(sc.test());  
 System.out.println(sc.test());  
 private ApplicationContext getWebApplicationContext()  
{ WebApplicationContext wac = null;  
 wac =  
(WebApplicationContext)getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
 return wac;  
 private ApplicationContext getClassPathApplicationContext()  
{ ClassPathXmlApplicationContext context = new  
ClassPathXmlApplicationContext("spring/serviceContext.xml");  
 return context;  
}

<?xmlversion="1.0"encoding="GBK"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.0.xsd"
default-autowire="byName"default-lazy-init="true">
<beanid="staticClass"class="com.test.StaticClass"/>
</beans>

<?xml  
version="1.0" encoding="GBK"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xmlns:aop="http://www.springframework.org/schema/aop"  
 xsi:schemaLocation="http://www.springframework.org/schema/beans  
http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
http://www.springframework.org/schema/aop  
http://www.springframework.org/schema/aop/spring-aop-2.0.xsd"  
 default-autowire="byName" default-lazy-init="true">  
 <bean id="staticClass" class="com.test.StaticClass"/>  
</beans>

private void x1(){  
    for(;;){  
        List c = new ArrayList();  
}

private void x1() {  
    for (;;) {  
        List c = new ArrayList();  
}

public class Servlet1 extends HttpServlet{  
    private static final String STATICNAME="Simple";  
    protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{  
}

public class Servlet1 extends HttpServlet {  
    private static final String STATICNAME = "Simple";  
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
}

package com.test;  
import java.io.*;  
import java.util.logging.*;  
import javax.servlet.*;  
import javax.servlet.http.*;  
public class LeakServlet extends HttpServlet{  
    private static final String STATICNAME = "Thisleaks!";  
    private static final Level CUSTOMLEVEL = new Level("test",550){};//anonclass!  
    protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{  
        Logger.getLogger("test").log(CUSTOMLEVEL,"doGetcalled");  
}

package com.test;  
import java.io.*;  
import java.util.logging.*;  
import javax.servlet.*;  
import javax.servlet.http.*;  
public class LeakServlet extends HttpServlet {  
    private static final String STATICNAME = "This leaks!";  
    private static final Level CUSTOMLEVEL = new Level("test", 550) {}; // anon class!    
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
        Logger.getLogger("test").log(CUSTOMLEVEL, "doGet called");  
}

public class Level implements java.io.Serializable{  
    private static java.util.ArrayList known = new java.util.ArrayList();  
    protected Level(String name,int value){  
        this(name,value,null);  
    protected Level(String name,int value,String resourceBundleName){  
        if(name==null){  
        throw new NullPointerException();  
        this.name=name;  
        this.value=value;  
        this.resourceBundleName=resourceBundleName;  
        synchronized(Level.class){known.add(this);}  
}

public class Level implements java.io.Serializable {  
    private static java.util.ArrayList known = new java.util.ArrayList();  
    protected Level(String name, int value) {  
        this(name, value, null);  
    protected Level(String name, int value, String resourceBundleName) {  
        if (name == null) {  
          throw new NullPointerException();    
        this.name = name;  
        this.value = value;  
        this.resourceBundleName = resourceBundleName;  
        synchronized (Level.class) { known.add(this); }  
}

public abstract class LogFactory{  
    protected static Hashtable factories=null;  
    publics tatic Log getLog(Class clazz) throws LogConfigurationException{  
        returngetFactory().getInstance(clazz);  
    public abstract Log getInstance(Class class1) throws LogConfigurationException;  
    public static LogFactory getFactory() throws LogConfigurationException{  
    ClassLoader contextClassLoader=getContextClassLoader();  
    LogFactory factory=getCachedFactory(contextClassLoader);  
    if(factory!=null)  
        return factory;  
    //下面大量的代码被删除，主要用于：创建由应用加载的新LogFactory对象factory  
    if(factory!=null){  
        cacheFactory(contextClassLoader,factory);  
        return factory;  
    private static void cache Factory(ClassLoader classLoader,LogFactory factory){  
    if(factory!=null)  
    if(classLoader==null)  
        nullClassLoaderFactory=factory;  
        factories.put(classLoader,factory);  
}

public abstract class LogFactory {  
 protected static Hashtable factories = null;  
public static Log getLog(Class clazz) throws LogConfigurationException {  
 return getFactory().getInstance(clazz);  
 public abstract Log getInstance(Class class1) throws LogConfigurationException;  
 public static LogFactory getFactory() throws LogConfigurationException {  
 ClassLoader contextClassLoader = getContextClassLoader();  
 LogFactory factory = getCachedFactory(contextClassLoader);  
 if (factory != null)  
 return factory;  
 //下面大量的代码被删除，主要用于：创建由应用加载的新LogFactory 对象 factory  
 if (factory != null) {  
 cacheFactory(contextClassLoader, factory);  
 return factory;  
 private static void cacheFactory(ClassLoader classLoader, LogFactory factory) {  
 if (factory != null)  
 if (classLoader == null)  
 nullClassLoaderFactory = factory;  
 factories.put(classLoader, factory);  
}

package java.beans;  
public class Introspector{  
    private static Map declaredMethodCache=Collections.synchronizedMap(newWeakHashMap());  
    private static Map beanInfoCache=Collections.synchronizedMap(newWeakHashMap());  
    public static BeanInfo getBeanInfo(Class<?>beanClass)throws IntrospectionException{  
        if(!ReflectUtil.isPackageAccessible(beanClass)){  
        return (new Introspector(beanClass,null,USE_ALL_BEANINFO)).getBeanInfo();  
    BeanInfo bi=(BeanInfo)beanInfoCache.get(beanClass);  
    if(bi==null){  
        bi=(new Introspector(beanClass,null,USE_ALL_BEANINFO)).getBeanInfo();  
        beanInfoCache.put(beanClass,bi);  
    returnbi;  
}

package java.beans;  
public class Introspector {  
 private static Map declaredMethodCache = Collections.synchronizedMap(new WeakHashMap());  
 private static Map beanInfoCache = Collections.synchronizedMap(new WeakHashMap());  
 public static BeanInfo getBeanInfo(Class<?> beanClass) throws IntrospectionException  
 if (!ReflectUtil.isPackageAccessible(beanClass)) {  
 return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();  
 BeanInfo bi = (BeanInfo)beanInfoCache.get(beanClass);  
 if (bi == null) {  
 bi = (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();  
 beanInfoCache.put(beanClass, bi);  
 return bi;  
}

package org.springframework.beans;  
......  
final class CachedIntrospectionResults{  
    private static final Log logger;  
    private static final Map classCache=Collections.synchronizedMap(newWeakHashMap());  
    private final BeanInfo beanInfo;  
    private final Map propertyDescriptorCache;  
    static{  
        logger=LogFactory.getLog(org.springframework.beans.CachedIntrospectionResults.class);  
    public static CachedIntrospectionResultsforClass(ClassbeanClass) throws BeansException{  
        CachedIntrospectionResults results=null;  
        Object value=classCache.get(beanClass);  
        if(results==null){  
            results=new CachedIntrospectionResults(beanClass);  
            boolean cacheSafe=isCacheSafe(beanClass);  
            if(logger.isDebugEnabled())  
                logger.debug("Class["+beanClass.getName()+"]is"+(cacheSafe?"":"not")+"cache-safe");  
            if(cacheSafe)  
                classCache.put(beanClass,results);  
                classCache.put(beanClass,new WeakReference(results));  
        } else if(logger.isDebugEnabled())  
            logger.debug("Usingcachedintrospectionresultsforclass["+beanClass.getName()+"]");  
        return  results;  
    private CachedIntrospectionResults(Class clazz) throws BeansException{  
        beanInfo=Introspector.getBeanInfo(clazz);  
        Class classToFlush=clazz;  
}

package org.springframework.beans;  
......  
final class CachedIntrospectionResults  
 private static final Log logger;  
 private static final Map classCache = Collections.synchronizedMap(new WeakHashMap());  
 private final BeanInfo beanInfo;  
 private final Map propertyDescriptorCache;  
 static  
 {logger = LogFactory.getLog(org.springframework.beans.CachedIntrospectionResults.class); }  
 public static CachedIntrospectionResults forClass(Class beanClass)  
 throws BeansException  
 CachedIntrospectionResults results = null;  
 Object value = classCache.get(beanClass);  
 if(results == null)  
 results = new CachedIntrospectionResults(beanClass);  
 boolean cacheSafe = isCacheSafe(beanClass);  
 if(logger.isDebugEnabled())  
 logger.debug("Class [" + beanClass.getName() + "] is " + (cacheSafe ? "" : "not ") + "cache-safe");  
 if(cacheSafe)  
 classCache.put(beanClass, results);  
 classCache.put(beanClass, new WeakReference(results));  
 } else  
 if(logger.isDebugEnabled())  
 logger.debug("Using cached introspection results for class [" + beanClass.getName() + "]");  
 return results;  
 private CachedIntrospectionResults(Class clazz)throws BeansException  
beanInfo = Introspector.getBeanInfo(clazz);  
 Class classToFlush = clazz;  
}

package org.apache.commons.beanutils;  
public class MethodUtils{  
privatestaticWeakHashMapcache=newWeakHashMap();  
    public static Method getAccessibleMethod(Class clazz,String methodName,Class parameterTypes[])  
        Method Descriptormd;  
        Method method;  
        md=new MethodDescriptor(clazz,methodName,parameterTypes,true);  
        method=(Method)cache.get(md);  
        if(method!=null)  
            return method;  
            method=getAccessibleMethod(clazz.getMethod(methodName,parameterTypes));  
            cache.put(md,method);  
            return method;  
        }catch(NoSuchMethodException e){  
            return null;  
}

package org.apache.commons.beanutils;  
public class MethodUtils  
private static WeakHashMap cache = new WeakHashMap();  
 public static Method getAccessibleMethod(Class clazz, String methodName, Class parameterTypes[])  
 MethodDescriptor md;  
 Method method;  
 md = new MethodDescriptor(clazz, methodName, parameterTypes, true);  
 method = (Method)cache.get(md);  
 if(method != null)  
 return method;  
 method = getAccessibleMethod(clazz.getMethod(methodName, parameterTypes));  
 cache.put(md, method);  
 return method;  
 }catch(NoSuchMethodException e){  
 return null;  
}

package com.test.enumeration;  
public enum OperationEnum{  
    QUOTE(1),ISSUE(2),RENEW(4),CANCEL(12),  
    ENDORSE(16),CHANGE(64),REINSTATE(192);  
    private int operation=0;  
    private OperationEnum(intop){  
        this.operation=op;  
    public boolean isNewOperation(){  
        return (this.operation==2)||  
        (this.operation==4)||  
        (this.operation==192);  
}

package com.test.enumeration;  
public enum OperationEnum {  
 QUOTE(1), ISSUE(2), RENEW(4), CANCEL(12),  
 ENDORSE(16), CHANGE(64), REINSTATE(192);  
 private int operation = 0;  
 private OperationEnum(int op) {  
 this.operation = op;  
 public boolean isNewOperation() {  
 return (this.operation==2) ||  
 (this.operation==4) ||  
 (this.operation==192);  
}

public class LeakCauseServletInOtherApp extends HttpServlet{  
    private final OperationEnum operation=OperationEnum.CHANGE;//  
    protected void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{  
        doSomething(request,response);  
}

public class LeakCauseServletInOtherApp extends HttpServlet {  
 private final OperationEnum operation = OperationEnum.CHANGE; //  
 protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {  
 doSomething(request, response);  
}

<?xmlversion="1.0"encoding="UTF-8"?>
<web-appid="WebApp_ID"version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>ClassLoader</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:spring/*.xml</param-value>
</context-param>
<!--Spring刷新Introspector防止内存泄露，推荐把此Listener放置在第一个，至少是Spring相关Listener的第一个-->
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
……

<?xml version="1.0" encoding="UTF-8"?>  
<web-app id="WebApp_ID" version="2.4"  
 xmlns="http://java.sun.com/xml/ns/j2ee"  
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">  
 <display-name>ClassLoader</display-name>  
 <context-param>  
 <param-name>contextConfigLocation</param-name>  
 <param-value>classpath*:spring/*.xml</param-value>  
 </context-param>  
 <!-- Spring 刷新Introspector防止内存泄露，推荐把此Listener放置在第一个，至少是Spring相关 Listener的第一个 -->  
 <listener>  
 <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
 </listener>  
 <listener>  
 <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
 </listener>  
……

package org.springframework.web.util;  
public class IntrospectorCleanupListener implements ServletContextListener{  
    public void contextInitialized(ServletContextEvent event){  
        CachedIntrospection Results.acceptClassLoader(Thread.currentThread().getContextClassLoader());  
    public void contextDestroyed(ServletContextEvent event){  
        CachedIntrospectionResults.clearClassLoader(Thread.currentThread().getContextClassLoader());  
        Introspector.flushCaches();  
}

package org.springframework.web.util;  
public class IntrospectorCleanupListener implements ServletContextListener {  
 public void contextInitialized(ServletContextEvent event) {  
 CachedIntrospectionResults.acceptClassLoader(Thread.currentThread().getContextClassLoader());  
 public void contextDestroyed(ServletContextEvent event) {  
 CachedIntrospectionResults.clearClassLoader(Thread.currentThread().getContextClassLoader());  
 Introspector.flushCaches();  
}

packagecom.test;  
import javax.servlet.ServletContextEvent;  
import javax.servlet.ServletContextListener;  
import org.apache.commons.logging.LogFactory;  
public class ApplicationLifecycleListener implements ServletContextListener{  
    publicvoidcontextDestroyed(final ServletContextEvent sce){  
    LogFactory.release(Thread.currentThread().getContextClassLoader());  
public void contextInitialized(final ServletContextEvent sce){  
}

package com.test;  
import javax.servlet.ServletContextEvent;  
import javax.servlet.ServletContextListener;  
import org.apache.commons.logging.LogFactory;  
public class ApplicationLifecycleListener implements ServletContextListener {  
 public void contextDestroyed(final ServletContextEvent sce) {  
 LogFactory.release(Thread.currentThread().getContextClassLoader());  
 public void contextInitialized(final ServletContextEvent sce) {  
}

<?xmlversion="1.0"encoding="UTF-8"?>
<web-appid="WebApp_ID"version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2eehttp://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>ClassLoader</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:spring/*.xml</param-value>
</context-param>
<!--Spring刷新Introspector防止内存泄露，推荐把此Listener放置在第一个，至少是Spring相关Listener的第一个-->
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

内存泄漏 - 从Class类加载器说起

内存泄漏 - 从Class类加载器说起

背景