java substring 性能_《Java程序性能优化》subString()方法的内存泄露

String的构造

首先了解下String的构造,String内部使用char [] value 来存储字符。

需要注意 offset和count在1.7已经没有了。

/** The value is used for character storage. */

private final char value[];

/** The offset is the first index of the storage that is used. */

private final int offset;//仅仅出现在1.7以下

/** The count is the number of characters in the String. */

private final int count;//仅仅出现在1.7以下

测试用例

环境: jdk1.6 之后为jdk1.7

运行参数 这里指定了最大堆为50m . 如果list仅仅存(5-1)*100个字符 应该是完全没问题的。

`-Xms50m -Xmx50m -XX:+PrintGCDetails`

public class MyTest {

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {

List list = new ArrayList<>();

for (int i = 0; i < 100; i++) {

list.add(new HugeStr().getSub());

// list.add(new ImprovedHugeStr().getSub());

}

Object o = list.get(99);

Field value = String.class.getDeclaredField("value");

value.setAccessible(true);

Object o1 = value.get(o);

if (o1 instanceof char[]) {

System.out.println(((char[]) o1).length);

}

}

public static class HugeStr{

private String str = new String(new char[1024*1024]);

public String getSub(){

return str.substring(1, 5);//1.7已经修复, 内部采用Arrays.copyOfRange

}

}

public static class ImprovedHugeStr{

private String str = new String(new char[1024*1024]);

public String getSub(){

return new String(str.substring(1, 5));//new String的时候会使用Arrays.copyOfRange 拷贝需要的部分。

}

}

}

jdk1.6 String代码部分实现

需要注意subString时传入的value是原字符串的char [] value.

new String 时，判断了offset与count.通过 Arrays.copyOfRange生成字符数组。

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);//此处value储存有原字符串的所有字符①

}

// Package private constructor which shares value array for speed.

String(int offset, int count, char value[]) {//subString最终调用此方法②

this.value = value;

this.offset = offset;

this.count = count;

}

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;

}

由上面代码可以知道。当使用HugeStr的getSub的时候，str.subString(1,5)返回的子串包含了原字符串的char数组 value.

jdk1.6中使用测试subString

①处 subString的value (v)和②处value代表原字符串str 的字符数组(长度大于4)。由于v的长度远大4，所以很快就内存不够，当内存不够发生gc的时候，v一直被子串b引用，导致无法回收。所以会报OOM。

看下测试效果:

一个子串包含了原字符串的所有char,1024*1024=148576

jdk1.6中使用修复后的代码测试subString

而ImprovedHugeStr的gutSub的时候， 实际在new String(str.substring(1, 5));的时候，返回的Arrays.copyOfRange拷贝的值(③)。已经失去了原字符串str 包括其value的引用，即使原字符串的value 很大，但是已经不被GC Roots对象链接到，会被回收。区区4长度*100的字符串， 不会引起OOM.

效果如图:

JDK1.7中已经修复了该问题

在new String内部使用了 Array.copyOfRange 拷贝。 原value 不再引用。当内存不够发生gc的时候，原value被回收。

jdk1.7 String代码部分实现

关键在 subString后调用的构造方法有改变。也是通过Arrays.copyOfRange拷贝。

public String substring(int beginIndex, int endIndex) {

if (beginIndex < 0) {

throw new StringIndexOutOfBoundsException(beginIndex);

}

if (endIndex > value.length) {

throw new StringIndexOutOfBoundsException(endIndex);

}

int subLen = endIndex - beginIndex;

if (subLen < 0) {

throw new StringIndexOutOfBoundsException(subLen);

}

return ((beginIndex == 0) && (endIndex == value.length)) ? this

: new String(value, beginIndex, subLen);

}

public String(char value[], int offset, int count) {//subString最终调用此构造方法

if (offset < 0) {

throw new StringIndexOutOfBoundsException(offset);

}

if (count < 0) {

throw new StringIndexOutOfBoundsException(count);

}

// Note: offset or count might be near -1>>>1.

if (offset > value.length - count) {

throw new StringIndexOutOfBoundsException(offset + count);

}

this.value = Arrays.copyOfRange(value, offset, offset+count);//此处是关键

}

public String(String original) {

this.value = original.value;//1.7的构造方法有改变。 成员不再有 count,offset

this.hash = original.hash;

}

测试效果:

参考