Java中的substring真的会引起内存泄露么?

标签: java substring 内存泄露 | 发表时间:2015-05-27 13:18 | 作者:coffeesweet
出处:http://www.iteye.com

转:

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

http://www.cnblogs.com/techyc/p/3324021.html

 

Java中的substring真的会引起内存泄露么?

Dec 14th, 2014

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

基本介绍

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

1
        public String substring(int beginIndex)

比如我们使用上面的方法, "unhappy".substring(2) 返回结果 "happy"

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

1
        public String substring(int beginIndex, int endIndex)

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

通过这个介绍我们基本了解了substring的作用,这样便于我们理解下面的内容。

准备工作

因为这个问题出现的情况在Java 6,如果你的Java版本号不是Java 6 需要调整一下。

终端调整(适用于Mac系统)

查看java版本号

1
2
3
4
        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

1
        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里用到的重现问题的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
        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方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
        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的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
        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);
}

上述方法调用的构造方法

1
2
3
4
5
6
        //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字符串的内容数组引用了。

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        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的实现抛弃了之前的内容字符数组共享的机制,对于子字符串(自身除外)采用了数组复制实现单个字符串持有自己的应该拥有的内容。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
        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方法中调用的构造方法,进行内容字符数组复制。

1
2
3
4
5
6
7
8
9
10
11
12
13
        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实现的更改也间接影响到了这些方法。

参考资源

以下三篇文章写得都比较不错,但是都稍微有一些问题,我都已经标明出来,大家阅读时,需要注意。

注意

上面的重现问题的代码中

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

这里最好不要写成下面这样,因为在JVM中存在字符串常量池,”ab”不会重新创建新字符串,所有的变量都会引用一个对象,而使用new String()则每次重新创建对象。

1
2
3
        String getString() {
      return "ab";
}

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

吐血推荐

如果你对本文这样的内容感兴趣,可以阅读以下Joshua Bloch大神写得书,虽然有点贵,还是英文的。 Java Puzzlers



已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [java substring 内存泄露] 推荐:

Java中的substring真的会引起内存泄露么?

- - 编程语言 - ITeye博客
Java中的substring真的会引起内存泄露么. 在Java中开发,String是我们开发程序可以说必须要使用的类型,String有一 个substring方法用来截取字符串,我们想必也常常使用. 但是你知道么,关于Java 6中的substring是否会引起内存泄露,在国外的论坛和社区有着一些讨论,以至于Java官方已经将其标记成bug,并且为此Java 7 还重新进行了实现.

Java的内存泄露

- - Java译站
Java有垃圾回收,因此不会出现内存泄露. 尽管Java的确有垃圾回收器来回收那些不用的内存块,但你不要指望它能够点铁成金. GC减轻了开发人员肩上的负担,而原本的那些工作非常容易出错,不过并不是所有内存分配的问题它都能够解决. 更糟糕的是,Java的设计允许它可以欺骗GC,使得它能够保留一些程序已经不再使用的内存.

诊断Java中的内存泄露

- - ImportNew
每次我怀疑有内存泄漏时,我都要翻箱倒柜找这些命令. 首先,我用下面的命令监视进程:. (如果有的话还有New Relic). 如果你看到内存上升很快,可能是因为虚拟机设置. 如果你没有明确指定JVM的内存设置,它将设置默认值给他们. 如果这些都不符合你所希望的,那么你就需要指定JVM的内存设置. 可以用下面的命令设置最小和最大堆大小:.

Java SE 6 故障排除指南 – 3、内存泄露

- - 码蜂笔记
如果你的应用程序执行的时间越来越长,或如果操作系统执行越来越慢,这可能是内存泄露的指示. 换句话说,虚拟内存被分配但在不需要时没有归还. 最终应用程序或系统没有可用内存,应用程序非正常终止. 这篇文章提供了一些涉及内存泄露的问题诊断的建议. 3.1 OutOfMemoryError 的含义. 一个最常见的内存泄露的指示是 java.lang.OutOfMemoryError 错误.

Java内存泄露的理解与解决

- - Java - 编程语言 - ITeye博客
转自: http://henryyang.iteye.com/blog/1188328. Java内存管理机制. 在C++ 语言中,如果需要动态分配一块内存,程序员需要负责这块内存的整个生命周期. 从申请分配、到使用、再到最后的释放. 这样的过程非常灵活,但是却十分繁琐,程序员很容易由于疏忽而忘记释放内存,从而导致内存的泄露.

如何用Java编写一段代码引发内存泄露

- - ImportNew
文本来自StackOverflow问答网站的一个热门讨论:如何用Java编写一段会发生内存泄露的代码. Q:刚才我参加了面试,面试官问我如何写出会发生内存泄露的Java代码. 这个问题我一点思路都没有,好囧. A1:通过以下步骤可以很容易产生内存泄露(程序代码不能访问到某些对象,但是它们仍然保存在内存中):.

Java 内存泄露的理解与解决过程

- - 极客521 | 极客521
本文详细地介绍了Java内存管理的原理,以及内存泄露产生的原因,同时提供了一些列解决Java内存泄露的方案,希望对各位Java开发者有所帮助. 在C++ 语言中,如果需要动态分配一块内存,程序员需要负责这块内存的整个生命周期. 从申请分配、到使用、再到最后的释放. 这样的过程非常灵活,但是却十分繁琐,程序员很容易由于疏忽而忘记释放内存,从而导致内存的泄露.

java内存泄露和内存溢出区别

- - 互联网 - ITeye博客
虽然jvm可以通过GC自动回收无用的内存,但是代码不好的话仍然存在内存溢出的风险. 最近在网上搜集了一些资料,现整理如下:. 一、为什么要了解内存泄露和内存溢出. 1、内存泄露一般是代码设计存在缺陷导致的,通过了解内存泄露的场景,可以避免不必要的内存溢出和提高自己的代码编写水平;. 2、通过了解内存溢出的几种常见情况,可以在出现内存溢出的时候快速的定位问题的位置,缩短解决故障的时间.

Java常见问题分析(内存溢出、内存泄露、线程阻塞等)

- - Java - 编程语言 - ITeye博客
Java垃圾回收机制(GC) . 堆内存3代分布(年轻代、老年代、持久代) . ML(内存泄露) OOM(内存溢出)问题现象及分析 . IBM DUMP分析工具使用介绍. Java应用CPU、线程问题分析. Java垃圾回收机制(GC). 1.GC机制作用 . 1.1 JVM自动检测和释放不再使用的对象内存 .

关于内存泄露

- - 银河里的星星
valgrind 详细说明  http://www.cnblogs.com/wangkangluo1/archive/2011/07/20/2111273.html. 近期Imgsrc一处内存泄露问题的查找和解决  http://rdc.taobao.com/blog/cs/?p=1651.