Why does my Java serialization show poor performance for single vs multiple conversions?

Question

Below is my benchmarking code. First I try to serialize a single object. Then I try to do the same thing one million times. I was expecting a proportional increase in timing. Instead I get

1323048944117 1323048944131
1323048944117 1323048944210

14ms for one object
93ms for 1mil objects

What is happening here? I'm most worried about the time for single object conversion which I'm hoping to get to the submillisecond level.

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Pojo implements Serializable {
    String blah = "11111111111111111111aaaaaaaaaaaaaaaaaaaa";
}

public class SerializeTest {
    public static void main(String[] args) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = null;
        Pojo pojo = new Pojo();
        long start = 0;
        long end1 = 0;
        try {
            out = new ObjectOutputStream(bos);
            start =  System.currentTimeMillis();
            out.writeObject(pojo);
            end1 = System.currentTimeMillis();
            for (int i=0;i<1000000;i++) {
                out.writeObject(pojo);
            }

        } catch (Exception ex) {

        }
        long end2 = System.currentTimeMillis();
        System.out.println(start + " " + end1);
        System.out.println(start + " " + end2);

    }
}

Read this: http://stackoverflow.com/questions/504103/how-do-i-write-a-correct-micro-benchmark-in-java — duffymo, Dec 05 '11 at 01:45

score 2 · Answer 1 · answered Dec 05 '11 at 02:07

2

Try to run the two in reverse. First the one million then single and see what happens.

answered Dec 05 '11 at 02:07

Mr1159pm

774
1
10
21

score 2 · Accepted Answer · edited May 23 '17 at 12:11

Ultimately @duffmo is right that your results are 98% about the problems with doing micro testing in Java than it is about serialization. He posted a good link to read.

Another factor that is confusing your test is that serialization is smart. Writing the first object writes all of the class and field information and the data. The 2nd to the nth write of the same object instance is only writing a reference to the first object. The first object looks to be ~120 bytes and each remaining one is only 5 bytes. It's also going to be tons faster because it does a lot less.

My test did the 1st object in 8ms, the next 1000 objects in 5ms, and then a million objects in 2000ms. This shows you mostly how fast serialization is. It also shows you that Java does some magic real-time optimizations that cause drastically non-linear speed graphs.

If you are trying to do some serialization speed testing I would make your Pojo class generate some random numbers (or a random string) and I would compare the serialization of 1000 objects to a million to have a better comparison of per-object serialization times. Either that or start the timing after you have written 1000 objects or something. For example, writing a different object produces a file that is ~10 times larger but only took 5600ms.

score 0 · Answer 3 · answered Dec 05 '11 at 01:52

0

Just FYI, your second time should actually be 79ms

The code should read:

System.out.println(end1+ " " + end2);

answered Dec 05 '11 at 01:52

James Bassett

9,458
4
35
68

This would be better as a comment. It doesn't really address his question. – Gray Dec 05 '11 at 02:49
1

Sorry @Gray, but I can't comment yet!!! I only just registered and have 17 reputation. It was the only way I could mention this. Feel free to incorporate it into your answer ;) – James Bassett Dec 05 '11 at 03:04
No worries. Forgot about that. – Gray Dec 05 '11 at 03:08

score 0 · Answer 4 · answered Dec 05 '11 at 02:41

Create a new 'pojo' object to send each time. You might also want to have different values for 'blah' in each instance of pojo. e.g. "" + Math.random().

I think you'll see the performance for the one million be more like you expect. IIRC when you serialize the same object again and again to the same stream, the Java libraries will cache it in a dictionary and only send a 'reference' back to the originally sent object. So that's why you're seeing such a crazy fast number for the million pojo stream.

Why does my Java serialization show poor performance for single vs multiple conversions?

4 Answers4