Java中的substring真的会引发内存泄露么？

原文地址

http://droidyue.com/blog/2014/12/14/substring-memory-issue-in-java/

在Java中开发，String是咱们开发程序能够说必需要使用的类型，String有一个substring方法用来截取字符串，咱们想必也经常使用。可是你知道么，关于Java 6中的substring是否会引发内存泄露，在国外的论坛和社区有着一些讨论，以致于Java官方已经将其标记成bug，而且为此Java 7 还从新进行了实现。读到这里可能你的问题就来了，substring怎么会引发内存泄露呢？那么咱们就带着问题，走进小黑屋，看看substring有没有内存泄露，又是怎么致使所谓的内存泄露。

基本介绍

substring方法提供两种重载，第一种为只接受开始截取位置一个参数的方法。

public String substring(int beginIndex)

好比咱们使用上面的方法，"unhappy".substring(2) 返回结果 "happy"

另外一种重载就是接受一个开始截取位置和一个结束截取位置的参数的方法。

public String substring(int beginIndex, int endIndex)

使用这个方法，"smiles".substring(1, 5) 返回结果 "mile"

经过这个介绍咱们基本了解了substring的做用，这样便于咱们理解下面的内容。

准备工做

由于这个问题出现的状况在Java 6，若是你的Java版本号不是Java 6 须要调整一下。

终端调整（适用于Mac系统）

查看java版本号

13:03 $ java -version
java version "1.8.0_25"
Java(TM) SE Runtime Environment (build 1.8.0_25-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode)

切换到1.6

export JAVA_HOME=$(/usr/libexec/java_home -v 1.6)

Ubuntu使用alternatives --config java，Fedora上面使用alternatives --config java。

若是你使用Eclipse，能够选择工程，右击，选择Properties（属性）— Java Compiler（Java编译器）进行特殊指定。

问题重现

这里贴一下java官方bug里用到的重现问题的代码。

public class TestGC {
    private String largeString = new String(new byte[100000]);
 
    String getString() {
        return this.largeString.substring(0,2);
    }
 
    public static void main(String[] args) {
        java.util.ArrayList list = new java.util.ArrayList();
        for (int i = 0; i < 1000000; i++) {
            TestGC gc = new TestGC();
            list.add(gc.getString());
        }
    }
}

然而上面的代码，只要使用Java 6 （Java 7和8 都不会抛出异常）运行一下就会报java.lang.OutOfMemoryError: Java heap space的异常，这说明没有足够的堆内存供咱们建立对象，JVM选择了抛出异常操做。

因而有人会说，是由于你每一个循环中建立了一个TestGC对象，虽然咱们加入ArrayList只是两个字符的字符串，可是这个对象中又存储largeString这么大的对象，这样必然会形成OOM的。

然而，其实你说的不对。好比咱们看一下这样的代码,咱们只修改getString方法

public class TestGC {
    private String largeString = new String(new byte[100000]);
 
    String getString() {
        //return this.largeString.substring(0,2);
      return new String("ab");
    }
 
    public static void main(String[] args) {
        java.util.ArrayList list = new java.util.ArrayList();
        for (int i = 0; i < 1000000; i++) {
            TestGC gc = new TestGC();
            list.add(gc.getString());
        }
 
    }
}

执行上面的方法，并不会致使OOM异常，由于咱们持有的时1000000个ab字符串对象，而TestGC对象（包括其中的largeString）会在java的垃圾回收中释放掉。因此这里不会存在内存溢出。

那么到底是什么致使的内存泄露呢？要研究这个问题，咱们须要看一下方法的实现，便可。

深刻Java 6实现

在String类中存在这样三个属性

value 字符数组，存储字符串实际的内容

offset 该字符串在字符数组value中的起始位置

count 字符串包含的字符的长度

Java 6中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;
}

当咱们读完上述的代码，咱们应该会豁然开朗，原来是这个样子啊！

当咱们调用字符串a的substring获得字符串b，其实这个操做，无非就是调整了一下b的offset和count，用到的内容仍是a以前的value字符数组，并无从新建立新的专属于b的内容字符数组。

举个和上面重现代码相关的例子，好比咱们有一个1G的字符串a，咱们使用substring(0,2)获得了一个只有两个字符的字符串b，若是b的生命周期要长于a或者手动设置a为null，当垃圾回收进行后，a被回收掉，b没有回收掉，那么这1G的内存占用依旧存在，由于b持有这1G大小的字符数组的引用。

看到这里，你们应该能够明白上面的代码为何出现内存溢出了。

共享内容字符数组

其实substring中生成的字符串与原字符串共享内容数组是一个很棒的设计，这样避免了每次进行substring从新进行字符数组复制。正如其文档说明的,共享内容字符数组为了就是速度。可是对于本例中的问题，共享内容字符数组显得有点蹩脚。

如何解决

对于以前比较不常见的1G字符串只截取2个字符的状况可使用下面的代码，这样的话，就不会持有1G字符串的内容数组引用了。

String littleString = new String(largeString.substring(0,2));

下面的这个构造方法，在源字符串内容数组长度大于字符串长度时，进行数组复制，新的字符串会建立一个只包含源字符串内容的字符数组。

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;
}

Java 7 实现

在Java 7 中substring的实现抛弃了以前的内容字符数组共享的机制，对于子字符串（自身除外）采用了数组复制实现单个字符串持有本身的应该拥有的内容。

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);
}

substring方法中调用的构造方法，进行内容字符数组复制。

public String(char value[], int offset, int count) {
    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);
}

真的是内存泄露么

咱们知道了substring某些状况下可能引发内存问题，可是这个叫作内存泄露么？

其实我的认为这个不该该算为内存泄露，使用substring生成的字符串b当然会持有原有字符串a的内容数组引用，可是当a和b都被回收以后，该字符数组的内容也是能够被垃圾回收掉的。

哪一个版本实现的好

关于Java 7 对substring作的修改，收到了褒贬不一的反馈。

我的更加倾向于Java 6的实现，当进行substring时，使用共享内容字符数组，速度会更快，不用从新申请内存。虽然有可能出现本文中的内存性能问题，但也是有方法能够解决的。

Java 7的实现不须要程序员特殊操做避免了本文中问题，可是进行每次substring的操做性能总会比java 6 的实现要差一些。这种实现显得有点“糟糕”。

问题的价值

虽然这个问题出如今Java 6而且Java 7中已经修复，但并不表明咱们就不须要了解，何况Java 7的从新实现被喷的很厉害。

其实这个问题的价值，仍是比较宝贵的，尤为是内容字符数组共享这个优化的实现。但愿能够为你们之后的设计实现提供帮助和一些想法。

受影响的方法

trim和subSequence都存在调用substring的操做。Java 6和Java 7 substring实现的更改也间接影响到了这些方法。

参考资源

如下三篇文章写得都比较不错，可是都稍微有一些问题，我都已经标明出来，你们阅读时，须要注意。

The substring() Method in JDK 6 and JDK 7 本文中解决java6中问题提到的字符串拼接不推荐，具体缘由能够参考Java细节：字符串的拼接

How SubString method works in Java – Memory Leak Fixed in JDK 1.7 本文中提到的有一个概念错误，新的字符串不会阻止旧的字符串被回收，而是阻止旧字符串中的内容字符数组。阅读时须要注意。

JDK-4513622 : (str) keeping a substring of a field prevents GC for object 本文中提到的有一个测试，使用非new的形式有一点问题，其忽视了字符串常量池的存在，具体查看下面的注意。

注意

上面的重现问题的代码中

String getString() {
  //return this.largeString.substring(0,2);
      return new String("ab");
}

这里最好不要写成下面这样，由于在JVM中存在字符串常量池，”ab”不会从新建立新字符串，全部的变量都会引用一个对象，而使用new String()则每次从新建立对象。

String getString() {
      return "ab";
}

关于字符串常量池，之后的文章会有介绍。

吐血推荐

若是你对本文这样的内容感兴趣，能够阅读如下Joshua Bloch大神写得书，虽然有点贵，仍是英文的。 Java Puzzlers