Java HeapDump分析：String或StringBuilder，应使用什么？

Question

In my application there was a heap dump and surprisingly heap retained by char[] was around 700MB, which was strange (at least for me). At the same time String had only 150MB.

In my application, I have only used StringBuilder (using default StringBuilder constructor) and tried to avoid using String as we were appending data.

My question here is: Should we always go for StringBuilder ? And if yes, how can we reduce the heap retained by it?

Answer 1

Possibly you can use StringInterner which takes a StringBuilder to avoid creating objects needlessly.You first populate a recycled StringBuilder with the text and if a String matching that text is in the interner, that String is returned (or a toString() of the StringBuilder is.) The benefit is that you only create objects (and no more than needed) when you see a new String (or at least one not in the array) This can get a 80% to 99% hit rate and reduce memory consumption (and garbage) dramatically when loading many strings of data.

Code: https://github.com/OpenHFT/Java-Lang/blob/master/lang/src/main/java/net/openhft/lang/pool/StringInterner.java

Answer 2

Yes, always go for StringBuilder when building strings - it's the most efficient, but still convenient, way of concatenating strings.

It sounds like there are lots of StringBuilder s hanging around waiting to be garbage collected. However, to reduce heap usage, you can safely reuse your StringBuilder s even though they are not threadsafe by using one StringBuilder per thread via Threadlocal :

private static final ThreadLocal<StringBuilder> LOCAL_STRING_BUILDER =
    ThreadLocal.withInitial(StringBuilder::new);

Example usage:

public String logMessage() {
    StringBuilder sb = LOCAL_STRING_BUILDER.get();
    sb.setLength(0); // Only resets the pointer to start. Doesn't affect the backing array
    sb.append("foo=").append(myField); //etc
    return sb.toString();
}

You will only ever have at most as many StringBuilder s as there are threads, which won't be that many (maybe 10's - 100's).

---

FYI StringBuilder is used when concatenating strings manually anyway; this line of source:

String str3 = str1 + str2;

gets compiled as if it were:

String str3 = new StringBuilder().append(str1).append(str2).toString();