从OutOfMemory错误看StringBuffer源码

从OutOfMemory错误看StringBuffer源码

上周灰度期间出现一个内存溢出错误,堆栈信息大概是下面这样的:
原始崩溃信息:

`    java.lang.OutOfMemoryError
        at java.lang.AbstractStringBuilder.enlargeBuffer(AbstractStringBuilder.java:94)
        at java.lang.AbstractStringBuilder.append0(AbstractStringBuilder.java:145)
        at java.lang.StringBuffer.append(StringBuffer.java:219)
        at com.suning.newstatistics.tools.a.a(Unknown Source)
        at com.suning.newstatistics.tools.f.f(Unknown Source)
        at com.suning.newstatistics.StatisticsTools.setCustomeEvent(Unknown Source) `

通过混淆前后的源码文件对比,最终我锁定崩溃在下面这段代码:

    public void appendInformation(String key, List<String> values) {
       String v = getString(key, "");

       StringBuffer buffer = new StringBuffer();
       if (!TextUtils.isEmpty(v)) {
          buffer.append(v).append(INFO_SEPARATE);
       }

       for (int i = 0; i < values.size(); i++) {
          buffer.append(values.get(i));
          if (i < values.size() - 1) {
             buffer.append(INFO_SEPARATE);
          }
       }

       putString(key, buffer.toString(), true);
       StatisticsLog.d(TAG, "save append v2 :" + key + "=" + buffer);
    }

我们可以很明显的看到,大概的逻辑是将集合values中的的字符串,通过for循环放到StringBuffer里面。而通过对比崩溃的堆栈的信息,我们也基本确定锁定崩溃的来源代码在于buffer.append这个方法。那么buffer.append这个方法调用的时候到底发生了什么?为什么会导致OOM?接下来让我们一起通过翻阅StringBuffer的源码,来寻找原因。

首先我们定位StringBuffer的append的方法里面:

StringBuffer.class:

    @Override
    public synchronized StringBuffer append(String str) {
       toStringCache = null;
       super.append(str);
       return this;
    }
首先toStringCache这个变量我们不用太多关注,只是一个缓存,每次append的时候,将其置为null。然后我们看到它调用了其父类AbstractStringBuilder的append的方法。

AbstractStringBuilder.class:

    public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        //拿到目标字符串的长度len
        int len = str.length();
        //扩容内部容器value的长度
        ensureCapacityInternal(count + len);
        //复制内容到value
        str.getChars(0, len, value, count);
        //更新内容长度count
        count += len;
        return this;
    }  

逻辑也很清晰,如果字符串为空,那么添加上一个“null”的字符串,其他的我也都加了注释。大概的步骤就是:扩容->复制这里我们要重点关注下ensureCapacityInternal()这个方法。

    //minimumCapacity:新老字符串的总长度    
    private void ensureCapacityInternal(int minimumCapacity) {
      // 如果新老字符串的总长度大于之前的长度,那么就去扩容当前的char数组value
      if (minimumCapacity - value.length > 0) {
         value = Arrays.copyOf(value,
         newCapacity(minimumCapacity));
      }
    }

    private int hugeCapacity(int minCapacity) {
      if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
         throw new OutOfMemoryError();
      }
      return (minCapacity > MAX_ARRAY_SIZE)? minCapacity : MAX_ARRAY_SIZE;
    }

Arrays.copyOf(char[] original, int newLength)这个方法就是扩容数组长度的一个方法。传入待扩容的数组original,并把目标长度newLength也传进去,如果newLength小于原数组长度,那么会截断;如果大于会填充空字符。执行完ensureCapacityInternal之后就可以得到一个变长的数组了。那么问题来了,为什么这里不是直接传入新老字符串的总长度去扩容:Arrays.copyOf(value,minimumCapacity),而是执行Arrays.copyOf(value,newCapacity(minimumCapacity))?接下来我们来看下newCapacity(minimumCapacity)这个方法:

    private int newCapacity(int minCapacity) {
       // overflow-conscious code
       int newCapacity = (value.length << 1) + 2;
      if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
      }
      return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
      ? hugeCapacity(minCapacity) : newCapacity;
    }

上面的代码,我翻译下就是这样的:

    private int newCapacity(int minCapacity) {

       int newContentLength =  minCapacity;
       int oldContetLength2Bei = (value.length << 1) + 2;
       int targetLength = 0;

       //原来长度是3,要扩展至5,那么因为3x2>5 ,所以会直接扩展至6 
       //原来长度是6,要扩展至18,那么因为6x2<18,所以直接扩展至18
       //原来长度是18,要扩展至20,那么因为18x2>20,所以直接扩展至36
       //也就是说每次至少会扩展至原长度的2倍,
       //即:如果要扩展到的长度大于之前的1倍,并且小于之前的2倍,都会扩展到之前的2倍
       if(oldContetLength2Bei >= newContentLength){
           targetLength = oldContetLength2Bei;
       }else{
           targetLength = newContentLength;
       }

       if(targetLength <= MAX_ARRAY_SIZE){
           return targetLength
       }else if(targetLength>MAX_ARRAY_SIZE && targetLength<Integer.MAX_VALUE){
           return targetLength    
       }else if(targetLength>MAX_ARRAY_SIZE && targetLength>Integer.MAX_VALUE){
          throw new OutOfMemoryError();
       }
    }

MAX_ARRAY_SIZE是一个比Integer.MAX_VALUE小8的数。之所以每次至少以2倍原长度为最小扩容单位,我感觉应该是底层的一些复制算法需要扩容至两倍的原长度,这里我们看到底层的源码,无法给出为什么这样做的确切原因。

由此可见,StringBuffer在append的时候,每次都会初始化一个至少大于原字符串长度2倍的数组,然后进行复制操作。并且当原字符串长度大于Integer.MAX_VALUE的一半的时候,因为每次至少会扩容至原长度的2倍,所以就会出现OOM。

评论

暂无评论