CODEWITHSUNDEEP
javaperformancefor-loop
Cambot
Cambot

Reputation: 257

Which manner of processing two repetative operations will be completed faster?

Generally speaking, is there a significant differance in the processing speeds of these two example segments of code, and if so, which should complete faster? Assume that "processA(int)" and "processB(int)" are voids that are common to both examples.

for(int x=0;x<1000;x++){
    processA(x);
    processB(x);
}

or

for(int x=0;x<1000;x++){
    processA(x);
}
for(int x=0;x<1000;x++){
    processB(x);
}

I'm looking to see if I can speed up one of my programs and it involves cycling through blocks of data several times and processing it differant ways. Currantly, it runs a seperate cycle for each processing method, meaning a lot of cycles get run in total, but each cycle does very little work. I was thinking about rewriting my code so that each cycle incorporates every processing method; in other words, much fewer cycles, but each cycle has a heavier workload.

This would be a very intensive rewrite of my program stucture. So unless it would give me a significant performance boost, it won't be worth the trouble.

Upvotes: 2

Views: 69

Answers (4)

Arash Saidi
Arash Saidi

Reputation: 2238

The first case will be slightly faster then the second case because a for loop in and of itself has an effect on performance. However, the main question you should ask yourself is this: will the effect be of significance to my program? If not, you should opt for clear and readable code.

One thing to remember in such a case is that the JVM (Java Virtual Machine) does a whole lot of optimisation, and in your case the JVM can even get rid of the for-loop and rewrite the code into 1000 successive calls to processA() and processB(). So even if you have two for loops, the JVM can get rid of both, making your program more optimal than even your first case.

To get a basic understanding of method calls, cost, and the JVM, you can read this short article:

https://plumbr.eu/blog/how-expensive-is-a-method-call-in-java

Upvotes: 2

rodd
rodd

Reputation: 193

The first piece of code is faster, because it only has one for loop.

If, however, you need to do something AFTER processA() has been executed n times and before processB()'s loop starts, then the second option would be ideal.

Upvotes: 1

Bathsheba
Bathsheba

Reputation: 234635

The single loop case will contain fewer instructions so will run faster.

But, unless processA and processB are very quick functions, such a substantial refactoring would give you negligible performance gain.

If this is production code, you should also take care as there may be side effects. You should make alterations in the context of a unit testing framework testing the code in question. (In C++ for example x may be passed by reference and could be modified by the functions! Of course Java has no such hazard but there may be other reasons why all processA functions have to run before all processB functions and the program comments may not make this clear).

Upvotes: 2

Alex D
Alex D

Reputation: 30445

Absolutely, fusing the 2 loops will be faster. (Some compilers do this automatically as an optimization.) How much faster? That depends on how many iterations the loops are running. Unless the number of iterations is very high, you can expect that the improvement will be minimal.

Upvotes: 2

Related Questions