Java: how much time does an empty loop use?

by

JIT triggers AFTER a certain piece of code has been executed many times.

The HotSpot JVM will try to identify “hot spots” in your code. Hot spots are pieces of your code that are executed many many times. To do this, the JVM will “count” the executions of various instructions, and when it determines a certain piece is executed frequently, it will trigger the JIT. (this is an approximation, but it’s easy to understand explained this way).

The JIT (Just-In-Time) takes that piece of code, and tries to make it faster.

The techniques used by the JIT to make your code run faster are a lot, but the one that most commonly creates confusion are :

  1. It will try to determine if that piece of code uses variables that are not used anywhere else (useless variables), and remove them.
  2. If you acquire and release the same lock multiple times (like calling synchronized methods of the same object), it can acquire the lock once and do all the calls in a single synchronized block
  3. If you access members of an object that are not declare volatile, it can decide to optimize it (placing values in registers and similar), creating strange results in multi-threading code.
  4. It will inline methods, to avoid the cost of the call.
  5. It will translate bytecode to machine code.
  6. If the loop is completely useless, it could be completely removed.

So, the proper answer to your question is that an empty loop, after being JITed, takes no time to execute .. most probably is not there anymore.

Again, there are many other optimizations, but in my experience these are among those that have created most headaches.

Moreover, JIT is being improved in any new version of Java, and sometimes it is even a bit different depending on the platform (since it is to some extent platform specific). Optimizations done by the JIT are difficult to understand, because you cannot usually find them using javap and inspecting bytecode, even if in recent versions of Java some of these optimizations have been moved to the compiler directly (for example, since Java 6 the compiler is able to detect and warn about unused local variables and private methods).

If you are writing some loops to test something, it is usually good practice to have the loop inside a method, call the method a few times BEFORE timing it, to give it a “speed up” round, and then perform the timed loop.

This usually triggers the JIT in a simple program like yours, even if there is no guarantee that it will actually trigger (or that it even exists on a certain platform).

If you want to get paranoid about JIT or non JIT timing (I did): make a first round, timing each execution of the loop, and wait until the timing stabilize (for example, difference from the average less than 10%), then start with your “real” timing.

More Related Contents:

  1. Does Java JIT compiler sacrifice performance to favor Collections?
  2. Why is printing “B” dramatically slower than printing “#”?
  3. Difference between declaring variables before or in loop?
  4. What is microbenchmarking?
  5. How to efficiently remove all null elements from a ArrayList or String Array?
  6. Increment variable names? [duplicate]
  7. Should try…catch go inside or outside a loop?
  8. Which one to use, int or Integer
  9. JAVA Looping a formula
  10. When to use StringBuilder in Java [duplicate]
  11. The performance impact of using instanceof in Java
  12. Performance of Java matrix math libraries? [closed]
  13. Fastest way to iterate over all the chars in a String
  14. A for-loop to iterate over an enum in Java
  15. Performance of StringTokenizer class vs. String.split method in Java
  16. Is there any performance reason to declare method parameters final in Java?
  17. Why is System.out.println so slow?
  18. Android RecyclerView Scrolling Performance
  19. Java HashMap performance optimization / alternative
  20. Does variable = null set it for garbage collection
  21. Fastest way to iterate an Array in Java: loop variable vs enhanced for statement [duplicate]
  22. JTable Calls Custom Cell Renderer Method… Continuously
  23. Fastest way to sum integers in text file
  24. Java try/catch performance, is it recommended to keep what is inside the try clause to a minimum?
  25. Should I avoid using Java Label Statements?
  26. fastest (low latency) method for Inter Process Communication between Java and C/C++
  27. What is the best macro-benchmarking tool / framework to measure a single-threaded complex algorithm in Java? [closed]
  28. Why doesn’t the JVM cache JIT compiled code?
  29. using labels in java without “loops”
  30. Using int vs Integer

Leave a Comment