java内存泄漏的分析方法

这几天,一直在为Java的“内存泄露”问题纠结。Java应用程序占用的内存在不断的、有规律的上涨,最终超过了监控阈值。福尔摩 斯不得不出手了! 内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间...

这几天,一直在为Java的“内存泄露”问题纠结。Java应用程序占用的内存在不断的、有规律的上涨,最终超过了监控阈值。福尔摩 斯不得不出手了!

 

内存溢出 out of memory,是指程序在申请内存时,没有足够的内存空间供其使用,出现out of memory;比如申请了一个integer,但给它存了long才能存下的数,那就是内存溢出。

内存泄露 memory leak,是指程序在申请内存后,无法释放已申请的内存空间,一次内存泄露危害可以忽略,但内存泄露堆积后果很严重,无论多少内存,迟早会被占光。

memory leak会最终会导致out of memory!

内存溢出就是你要求分配的内存超出了系统能给你的,系统不能满足需求,于是产生溢出。 

    内存泄漏是指你向系统申请分配内存进行使用(new),可是使用完了以后却不归还(delete),结果你申请到的那块内存你自己也不能再访问(也许你把它的地址给弄丢了),而系统也不能再次将它分配给需要的程序。一个盘子用尽各种方法只能装4个果子,你装了5个,结果掉倒地上不能吃了。这就是溢出!比方说栈,栈满时再做进栈必定产生空间溢出,叫上溢,栈空时再做退栈也产生空间溢出,称为下溢。就是分配的内存不足以放下数据项序列,称为内存溢出. 

    从用户使用程序的角度来看,内存泄漏本身不会产生什么危害,作为一般的用户,根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积,这会最终消耗尽系统所有的内存。从这个角度来说,一次性内存泄漏并没有什么危害,因为它不会堆积,而隐式内存泄漏危害性则非常大,因为较之于常发性和偶发性内存泄漏它更难被检测到

分析内存泄露的一般步骤

     如果发现Java应用程序占用的内存出现了泄露的迹象,那么我们一般采用下面的步骤分析

00001. 把Java应用程序使用的heap dump下来

00002. 使用Java heap分析工具,找出内存占用超出预期(一般是因为数量太多)的嫌疑对象

00003. 必要时,需要分析嫌疑对象和其他对象的引用关系。

00004. 查看程序的源代码,找出嫌疑对象数量过多的原因。

dump heap

    如果Java应用程序出现了内存泄露,千万别着急着把应用杀掉,而是要保存现场。如果是互联网应用,可以把流量切到其他服务器。保存现场的目的就是为了把 运行中JVM的heap dump下来。

    JDK自带的jmap工具,可以做这件事情。它的执行方法是:

Java代码   

00001. jmap -dump:format=b,file=heap.bin <pid>  

 

    format=b的含义是,dump出来的文件时二进制格式。

    file-heap.bin的含义是,dump出来的文件名是heap.bin。

    <pid>就是JVM的进程号。

    (在linux下)先执行ps aux | grep java,找到JVM的pid;然后再执行jmap -dump:format=b,file=heap.bin <pid>,得到heap dump文件。

analyze heap

    将二进制的heap dump文件解析成human-readable的信息,自然是需要专业工具的帮助,这里推荐Memory Analyzer 。

    Memory Analyzer,简称MAT,是Eclipse基金会的开源项目,由SAP和IBM捐助。巨头公司出品的软件还是很中用的,MAT可以分析包含数亿级对 象的heap、快速计算每个对象占用的内存大小、对象之间的引用关系、自动检测内存泄露的嫌疑对象,功能强大,而且界面友好易用。

    MAT的界面基于Eclipse开发,以两种形式发布:Eclipse插件和Eclipe RCP。MAT的分析结果以图片和报表的形式提供,一目了然。总之个人还是非常喜欢这个工具的。下面先贴两张官方的screenshots:

 

    言归正传,我用MAT打开了heap.bin,很容易看出,char[]的数量出其意料的多,占用90%以上的内存 。一般来说,char[]在JVM确实会占用很多内存,数量也非常多,因为String对象以char[]作为内部存储。但是这次的char[]太贪婪 了,仔细一观察,发现有数万计的char[],每个都占用数百K的内存 。这个现象说明,Java程序保存了数以万计的大String对象 。结合程序的逻辑,这个是不应该的,肯定在某个地方出了问题。 

顺藤摸瓜 

    在可疑的char[]中,任意挑了一个,使用Path To GC Root功能,找到该char[]的引用路径,发现String对象是被一个HashMap中引用的 。这个也是意料中的事情,Java的内存泄露多半是因为对象被遗留在全局的HashMap中得不到释放。不过,该HashMap被用作一个缓存,设置了缓 存条目的阈值,导达到阈值后会自动淘汰。从这个逻辑分析,应该不会出现内存泄露的。虽然缓存中的String对象已经达到数万计,但仍然没有达到预先设置 的阈值(阈值设置地比较大,因为当时预估String对象都比较小)。 

    但是,另一个问题引起了我的注意:为什么缓存的String对象如此巨大?内部char[]的长度达数百K。虽然缓存中的 String对象数量还没有达到阈值,但是String对象大小远远超出了我们的预期,最终导致内存被大量消耗,形成内存泄露的迹象(准确说应该是内存消 耗过多) 。 

就这个问题进一步顺藤摸瓜,看看String大对象是如何被放到HashMap中的。通过查看程序的源代码,我发现,确实有String大对象,不过并没有把String大对象放到HashMap中,而是把String大对象进行split(调用String.split方法),然后将split出 来的String小对象放到HashMap中 了。

    这就奇怪了,放到HashMap中明明是split之后的String小对象,怎么会占用那么大空间呢?难道是String类的split方法有问题? 

查看代码 

    带着上述疑问,我查阅了Sun JDK6中String类的代码,主要是是split方法的实现:

Java代码 

00001. public   

00002. String[] split(String regex, int limit) {  

00003.     return Pattern.compile(regex).split(this, limit);  

00004. }  

可以看出,Stirng.split方法调用了Pattern.split方法。继续看Pattern.split方法的代码:

Java代码 

00001. public   

00002. String[] split(CharSequence input, int limit) {  

00003.         int index = 0;  

00004.         boolean matchLimited = limit > 0;  

00005.         ArrayList<String> matchList = new   

00006. ArrayList<String>();  

00007.         Matcher m = matcher(input);  

00008.         // Add segments before each match found  

00009.         while(m.find()) {  

00010.             if (!matchLimited || matchList.size() < limit - 1) {  

00011.                 String match = input.subSequence(index,   

00012. m.start()).toString();  

00013.                 matchList.add(match);  

00014.                 index = m.end();  

00015.             } else if (matchList.size() == limit - 1) { // last one  

00016.                 String match = input.subSequence(index,  

00017.                                                    

00018. input.length()).toString();  

00019.                 matchList.add(match);  

00020.                 index = m.end();  

00021.             }  

00022.         }  

00023.         // If no match was found, return this  

00024.         if (index == 0)  

00025.             return new String[] {input.toString()};  

00026.         // Add remaining segment  

00027.         if (!matchLimited || matchList.size() < limit)  

00028.             matchList.add(input.subSequence(index,   

00029. input.length()).toString());  

00030.         // Construct result  

00031.         int resultSize = matchList.size();  

00032.         if (limit == 0)  

00033.             while (resultSize > 0 &&   

00034. matchList.get(resultSize-1).equals(""))  

00035.                 resultSize--;  

00036.         String[] result = new String[resultSize];  

00037.         return matchList.subList(0, resultSize).toArray(result);  

00038.     }  

    注意看第9行:Stirng match = input.subSequence(intdex, m.start()).toString();

这里的match就是split出来的String小对象,它其实是String大对象subSequence的结果。继续看 String.subSequence的代码:

Java代码 

00001. public   

00002. CharSequence subSequence(int beginIndex, int endIndex) {  

00003.         return this.substring(beginIndex, endIndex);  

00004. }  

    String.subSequence有调用了String.subString,继续看:

Java代码 

00001. public String   

00002. substring(int beginIndex, int endIndex) {  

00003.     if (beginIndex < 0) {  

00004.         throw new StringIndexOutOfBoundsException(beginIndex);  

00005.     }  

00006.     if (endIndex > count) {  

00007.         throw new StringIndexOutOfBoundsException(endIndex);  

00008.     }  

00009.     if (beginIndex > endIndex) {  

00010.         throw new StringIndexOutOfBoundsException(endIndex - beginIndex);  

00011.     }  

00012.     return ((beginIndex == 0) && (endIndex == count)) ? this :  

00013.         new String(offset + beginIndex, endIndex - beginIndex, value);  

00014.     }  

    看第11、12行,我们终于看出眉目,如果subString的内容就是完整的原字符串,那么返回原String对象;否则,就会创建一个新的 String对象,但是这个String对象貌似使用了原String对象的char[]。我们通过String的构造函数确认这一点:

Java代码 

00001. // Package   

00002. private constructor which shares value array for speed.  

00003.     String(int offset, int count, char value[]) {  

00004.     this.value = value;  

00005.     this.offset = offset;  

00006.     this.count = count;  

00007.     }  

    为了避免内存拷贝、加快速度,Sun JDK直接复用了原String对象的char[],偏移量和长度来标识不同的字符串内容。也就是说,subString出的来String小对象 仍然会指向原String大对象的char[],split也是同样的情况 。这就解释了,为什么HashMap中String对象的char[]都那么大。

原因解释

 

    其实上一节已经分析出了原因,这一节再整理一下:

00001. 程序从每个请求中得到一个String大对象,该对象内部char[]的长度达数百K。

00002. 程序对String大对象做split,将split得到的String小对象放到HashMap中,用作缓存。

00003. Sun JDK6对String.split方法做了优化,split出来的Stirng对象直接使用原String对象的char[]

00004. HashMap中的每个String对象其实都指向了一个巨大的char[]

00005. HashMap的上限是万级的,因此被缓存的Sting对象的总大小=万*百K=G级。

00006. G级的内存被缓存占用了,大量的内存被浪费,造成内存泄露的迹象。

解决方案

 

    原因找到了,解决方案也就有了。split是要用的,但是我们不要把split出来的String对象直接放到HashMap中,而是调用一下 String的拷贝构造函数String(String original),这个构造函数是安全的,具体可以看代码:

Java代码 

00001.     /** 

00002.      * Initializes a newly created {@code String} object so that it  

00003. represents 

00004.      * the same sequence of characters as the argument; in other words,  

00005. the 

00006.      * newly created string is a copy of the argument string. Unless an 

00007.      * explicit copy of {@code original} is needed, use of this  

00008. constructor is 

00009.      * unnecessary since Strings are immutable. 

00010.      * 

00011.      * @param  original 

00012.      *         A {@code String} 

00013.      */  

00014.     public String(String original) {  

00015.     int size = original.count;  

00016.     char[] originalValue = original.value;  

00017.     char[] v;  

00018.     if (originalValue.length > size) {  

00019.         // The array representing the String is bigger than the new  

00020.         // String itself.  Perhaps this constructor is being called  

00021.         // in order to trim the baggage, so make a copy of the array.  

00022.             int off = original.offset;  

00023.             v = Arrays.copyOfRange(originalValue, off, off+size);  

00024.     } else {  

00025.         // The array representing the String is the same  

00026.         // size as the String, so no point in making a copy.  

00027.         v = originalValue;  

00028.     }  

00029.     this.offset = 0;  

00030.     this.count = size;  

00031.     this.value = v;  

00032.     }  

    只是,new String(string)的代码很怪异,囧。或许,subString和split应该提供一个选项,让程序员控制是否复用String对象的 char[]。

是否Bug

 

    虽然,subString和split的实现造成了现在的问题,但是这能否算String类的bug呢?个人觉得不好说。因为这样的优化是比较合理 的,subString和spit的结果肯定是原字符串的连续子序列。只能说,String不仅仅是一个核心类,它对于JVM来说是与原始类型同等重要的 类型。

 

    JDK实现对String做各种可能的优化都是可以理解的。但是优化带来了忧患,我们程序员足够了解他们,才能用好他们。

一些补充

有个地方我没有说清楚。

 

我的程序是一个Web程序,每次接受请求,就会创建一个大的String对象,然后对该String对象进行split,最后split之后的String对象放到全局缓存中。如果接收了5W个请求,那么就会有5W个大String对象。这5W个大String对象都被存储在全局缓存中,因此会造成内存泄漏。我原以为缓存的是5W个小String,结果都是大String。

 

“抛出异常的爱”同学,在回帖(第7页)中建议用"java.io.StreamTokenizer"来解决本文的问题。确实是终极解决方案,比我上面提到的“new String()”,要好很多很多。

本文标题为:java内存泄漏的分析方法

基础教程推荐