Question

I’m writing lots of stuff to log in bursts, and optimizing the data path. I build the log text with StringBuilder. What would be the most efficient initial capacity, memory management wise, so it would work well regardless of JVM? Goal is to avoid reallocation almost always, which should be covered by initial capacity of around 80-100. But I also want to waste as few bytes as possible, since the StringBuilder instance may hang around in buffer and wasted bytes crop up.

I realize this depends on JVM, but there should be some value, which would waste least bytes, no matter the JVM, sort of “least common denominator”. I am currently using 128-16, where the 128 is a nice round number, and subtraction is for allocation overhead. Also, this might be considered a case of “premature optimization”, but since the answer I am after is a “rule-of-a-thumb” number, knowing it would be useful in future too.

I’m not expecting “my best guess” answers (my own answer above is already that), I hope someone has researched this already and can share a knowledge-based answer.

Answer 1

Well, I ended up testing this briefly myself, and then testing some more after comments, to get this edited answer.

Using JDK 1.7.0_07 and test app reporting VM name “Java HotSpot(TM) 64-Bit Server VM”, granularity of StringBuilder memory usage is 4 chars, increasing at even 4 chars.

Answer: any multiple of 4 is equally good capacity for StringBuilder from memory allocation point of view, at least on this 64-bit JVM.

Tested by creating 1000000 StringBuilder objects with different initial capacities, in different test program executions (to have same initial heap state), and printing out ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed() before and after.

Printing out heap sizes also confirmed, that amount actually allocated from heap for each StringBuilder‘s buffer is an even multiple of 8 bytes, as expected since Java char is 2 bytes long. In other words, allocating 1000000 instances with initial capacity 1..4 takes about 8 megabytes less memory (8 bytes per instace), than allocating same number of isntances with initial capacity 5…8.