Look at this piece of code:
MessageParser parser = new MessageParser();
for (int i = 0; i < 10000; i++) {
parser.parse(plainMessage, user);
}
For some reason, it runs SLOWER (by about 100ms) than
for (int i = 0; i < 10000; i++) {
MessageParser parser = new MessageParser();
parser.parse(plainMessage, user);
}
Any ideas why? The tests were repeated a lot of times, so it wasn't just random. How could creating an object 10000 times be faster than creating it once?
Because Java has 'generational garbage collection' and can quickly identify (in the loop) that it doesn't re-use the same object/memory space, so the GC cost is virtually nil. On the other hand, your long-lived object will survive a generational pass over the nursery generation and have to be moved out to the main generation.
In summary, you can't really assume about performance without doing tests to measure it in place.
There may be some logic to clean up the internal state on a subsequent call to parser.
Did the GC run during your benchmark? It's fairly cheap to instantiate a new object, and it's not a fair comparison if you don't count the time to dispose of all of the objects you created in the faster case.
I have no idea what MessageParser does or where it comes from. It may be "leaking" internally. Another possibility is that the object become further away from the data created during the parsing. This means you are likely to get a TLA miss. Also if the the MessageParser keeps internal state, and moves into the tenured generation the GC mechanics of noting that it references new data can be a problem ("card scoring" is jargon that pops to mind).
What happens if you benchmark the first example while restricting the scope of parser, ie
{
MessageParser parser = new MessageParser();
for (int i = 0; i < 10000; i++) {
parser.parse(plainMessage, user);
}
}
// `parser` no longer visible
I'd expect this to be fastest as only one object has to be created, and the VM still knows that parser can be gc'd immediately after the loop.
