从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。

评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论