Question

Out of curiosity, I measured the performance between static block and static method initializer. First, I implemented the above mentioned methods in two separate java classes, like so:

First:

class Dummy {
    static java.util.List<Integer> lista = new java.util.ArrayList<Integer>();
    static {
        for(int i=0; i < 1000000; ++i) {
            lista.add(new Integer(i));
        }
    }
}

public class First {
    public static void main(String[] args) { 
        long st = System.currentTimeMillis();
            Dummy d = new Dummy();
        long end = System.currentTimeMillis() - st;
        System.out.println(end);    
    }
}

Second:

class Muddy {
    static java.util.List<Integer> lista = new java.util.ArrayList<Integer>();
    public static void initList() {
        for(int i=0; i < 1000000; ++i) {
            lista.add(new Integer(i));
        }
    }
}

public class Second {
    public static void main(String[] args) { 
        long st = System.currentTimeMillis();
            Muddy.initList();
            Muddy m = new Muddy();
        long end = System.currentTimeMillis() - st;
        System.out.println(end);    
    }
}

Then I executed this little batch script to measure it 100 times and put the values in a file. batchFile.bat First Second dum.res.txt

After that, I wrote this piece of code to calculate mean value and standard deviation of Dummy’s and Muddy’s measured values.

This is the result that I’ve got:

First size: 100 Second size: 100
First       Sum: 132    Std. deviation: 13
Second      Sum: 112    Std. deviation: 9

And it is similar on my other machines…every time I test it.

Now I’m wondering, why is it so? I checked the bytecode and Second.class has one instruction more (call to static initList()) between calls to System.currentTimeMillis().
They both do the same thing, but why is the First one slower? I can’t really reason it out just by looking at the bytecode, since this was my first time touching javap; I don’t understand bytecode yet.

Answer 1

I think that the reason why the static block version is slower than the static method version could be due to the different JIT optimization that they get …

See this interesting article for more interesting information : Java Secret: Are static blocks interpreted?