CODEWITHSUNDEEP
java
Tom
Tom

Reputation: 3346

In Java, for primitive arrays, is reusing arrays signifcantly faster than repeatedly recreating them?

In Java, for primitive arrays, is reusing arrays signifcantly faster than repeatedly recreating them?

The following snippet is a comparison of the two cases: (a) reuse an array by System.arrayCopy vs (b) repeatedly create an array of specified values, in an intensive loop. 

public static void testArrayAllocationVsCopyPerformance() {
    long time = System.currentTimeMillis();
    final int length = 3000;

    boolean[] array = new boolean[length];

    boolean[] backup = new boolean[length];
    //for (int j = 0; j < length; j++) {
    //    backup [j] = true;
    //}

    for (int i = 0; i < 10000000; i++) {
        //(a). array copy
        //System.arraycopy(backup, 0, array, 0, length);

        //(b). reconstruct arrays
        array = new boolean[length];
        //for (int j = 0; j < length; j++) {
        //    array[j] = true;
        //}
    }

    long millis =  System.currentTimeMillis() - time;
    System.out.println("Time taken: " + millis + " milliseconds.");

    System.exit(0);
}

On my PC, (b) takes around 2600 milliseconds in average, while (a) takes around 450 milliseconds in average. For recreating an array with different values, the performance gap grows wider: (b) takes around 3750 milliseconds in average, while (a) remains constant, still 450 milliseconds in average.

In the snippet above, if 'boolean' are changed to 'int', the results are similar: reusing the int array takes around one thirds of recreating arrays. In addition, the (b) is also not far less readable than (a); (b) is just slightly less readable than (a) which does not need the 'backup' array.

However, answers of similar questions on stackoverflow or stackexchange regarding Java object creation are always things like "don't optimize it until it becomes a bottleneck", "JIT or JVM handles today can handle these better and faster than yourself", "keep it simple for readibility", etc. And these kinds of answers are typically well received by viewers.

The question is: can the performance comparison snippet above show that array copy is significantly faster compared to array re-creation wrt using short lived primitive arrays? Is the snippet above flawed? Or people still shouldn't optimize it until it becomes a bottleneck, etc?

Upvotes: 1

Views: 399

Answers (1)

Jaroslaw Pawlak
Jaroslaw Pawlak

Reputation: 5578

Can the performance comparison snippet above show that array copy is significantly faster compared to array re-creation wrt using short lived primitive arrays?

Yes, however you don't really need to prove it. Array occupies a continuous space in the memory. System.arraycopy is a native function, which is dedicated to copying arrays. It is obvious that it will be faster than creating the array, iterating over it, increasing the counter on every iteration, checking the boolean expression whether the loop should terminate, assigning the primitive to the certain position in the array, etc.

You should also remember that compilers nowadays are quite smart and they might replace your code with a more efficient version. In such case, you would not observe any difference in the test you wrote. Also, keep in mind that Java uses just-in-time compiler, which might optimize your code after you run it a lot of times and it decides that the optimization is worth doing.

Is the snippet above flawed?

Yes, it is flawed. What you are doing here is microbenchmarking. However, you haven't done any warm-up phase. I suggest to do some more reading about this topic.

Or people still shouldn't optimize it until it becomes a bottleneck, etc?

You should never do premature optimizations. If there are performance issues, run the code with profiler enabled, identify bottleneck and fix the problem.

However, you should also use some common sense. If you have a List and are adding elements at the front, use LinkedList, not ArrayList. If you need to copy entire array, use System.arraycopy instead of looping over it and doing it manually.

Upvotes: 3

Related Questions