分析和解决 JAVA 内存泄露的实战例子

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


public   
String[] split(String regex, int limit) {  
    return Pattern.compile(regex).split(this, limit);  
}  


public   
String[] split(CharSequence input, int limit) {  
        int index = 0;  
        boolean matchLimited = limit > 0;  
        ArrayList<String> matchList = new   
ArrayList<String>();  
        Matcher m = matcher(input);  
        // Add segments before each match found  
        while(m.find()) {  
            if (!matchLimited || matchList.size() < limit - 1) {  
                String match = input.subSequence(index,   
m.start()).toString();  
                matchList.add(match);  
                index = m.end();  
            } else if (matchList.size() == limit - 1) { // last one  
                String match = input.subSequence(index,  
                                                   
input.length()).toString();  
                matchList.add(match);  
                index = m.end();  
            }  
        }  
        // If no match was found, return this  
        if (index == 0)  
            return new String[] {input.toString()};  
        // Add remaining segment  
        if (!matchLimited || matchList.size() < limit)  
            matchList.add(input.subSequence(index,   
input.length()).toString());  
        // Construct result  
        int resultSize = matchList.size();  
        if (limit == 0)  
            while (resultSize > 0 &&   
matchList.get(resultSize-1).equals(""))  
                resultSize--;  
        String[] result = new String[resultSize];  
        return matchList.subList(0, resultSize).toArray(result);  
    }  
    注意看第9行：Stirng match = input.subSequence(intdex, m.start()).toString();


public   
CharSequence subSequence(int beginIndex, int endIndex) {  
        return this.substring(beginIndex, endIndex);  
}  
    String.subSequence有调用了String.subString，继续看：


public String   
substring(int beginIndex, int endIndex) {  
    if (beginIndex < 0) {  
        throw new StringIndexOutOfBoundsException(beginIndex);  
    }  
    if (endIndex > count) {  
        throw new StringIndexOutOfBoundsException(endIndex);  
    }  
    if (beginIndex > endIndex) {  
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);  
    }  
    return ((beginIndex == 0) && (endIndex == count)) ? this :  
        new String(offset + beginIndex, endIndex - beginIndex, value);  
    }  


// Package   
private constructor which shares value array for speed.  
    String(int offset, int count, char value[]) {  
    this.value = value;  
    this.offset = offset;  
    this.count = count;  
    }  


    /** 
     * Initializes a newly created {@code String} object so that it  
represents 
     * the same sequence of characters as the argument; in other words,  
the 
     * newly created string is a copy of the argument string. Unless an 
     * explicit copy of {@code original} is needed, use of this  
constructor is 
     * unnecessary since Strings are immutable. 
     * 
     * @param  original 
     *         A {@code String} 
     */  
    public String(String original) {  
    int size = original.count;  
    char[] originalValue = original.value;  
    char[] v;  
    if (originalValue.length > size) {  
        // The array representing the String is bigger than the new  
        // String itself.  Perhaps this constructor is being called  
        // in order to trim the baggage, so make a copy of the array.  
            int off = original.offset;  
            v = Arrays.copyOfRange(originalValue, off, off+size);  
    } else {  
        // The array representing the String is the same  
        // size as the String, so no point in making a copy.  
        v = originalValue;  
    }  
    this.offset = 0;  
    this.count = size;  
    this.value = v;  
    }