读书笔记之Java程序性能优化

最新推荐文章于 2018-09-19 10:02:54 发布

小鸡也疯狂

最新推荐文章于 2018-09-19 10:02:54 发布

阅读量434

点赞数

分类专栏： JDK 文章标签： OOM JAVA substring 读书笔记内存溢出

本文链接：https://blog.csdn.net/jifengwan/article/details/45998459

版权

JDK 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

最近在“Java程序性能优化”一书上看到“subString内存溢出优化”，一开始以为这是Java的Bug，看完才明白Java是采用空间换时间的策略，来提升生成字符串的速度，但因为牺牲了空间所以有可能出现内存溢出。

首先说明一下：因为此问题是在Java6会出现，而Java7采用其他方法避免了。所以我演示使用的JDK分别是jdk1.6.0_45和jdk1.7.0_40。

问题重现

因为Java官网有说明，所以使用他们代码重现这个Bug。

Bug地址：http://bugs.java.com/view_bug.do?bug_id=4513622

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不会抛出异常）运行一下就会报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的垃圾回收中释放掉。所以这里不会存在内存溢出。

那么究竟是什么导致的内存泄露呢？要研究这个问题，我们需要看一下方法的实现，即可。

源码分析

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

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

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

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

Java 6中substring的实现有两个：

public String substring(int beginIndex)
public String substring(int beginIndex, int endIndex)

查阅源代码可知，第一个substring实质是调用第二个substring的，如下：

public String substring(int beginIndex) {
      return substring(beginIndex, count);
}

第二个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);
}

方法最后，返回一个新建的String对象。查看该Stirng 的构造函数：

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

在源代码的注释中说明，这是一个包作用域的构造函数，其目的是快速地共享String内的char数组对象。但在这种通过偏移量来截取字符串的方法中，String的原生内容value数组被复制到新的子字符串中。设想，如果原字符串很大，截取的字符串长度缺很短，那么截取的字符串中包含了原生字符串的所有内容，并占据了相应的内存空间，而仅仅通过偏移量和长度来决定自己的实际取值。这种算法提高了运算速度却浪费了大量的内存空间。

如何解决

对于之前比较不常见的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);
}