如何查看完成方法调用所花费的时间？

Question

I want to do some research to improve my programmer skills by seeing see how long a method takes to finish.

But I don't want to write any code in the java files I am testing because I have a lot of methods to test (for some of the code I do not have permission to edit the code) so if possible I just want to "watch" the methods.

For example:

public void methodZero(){
  methodOne();
  methodTwo();
}

Should ideally print something like:

Time of methodZero = x. Time of methodOne = y. Time of methodTwo = z.

Question: Can I measure timing like this? Is there some additional info that would be important to me, like memory use?

Answer 1

Timing a method in isolation is usually completely meaningless, for a start you need statistical samples. If you want to get run times for a method you have to take a lot of things into consideration and give as much context to the target of your timing as possible.

For example, suppose your method has a return value, but you don't use it in any way in your benchmark - you are possibly going to encounter "dead-code elimination" by the JVM, which makes your timings meaningless. The JVM does many clever things like this ( openjdk.net: Performance techniques used in the Hotspot JVM ), all of which confuse and complicate taking meaningful timings.

A good library to use to help you do this (that also has good documentation and tutorials) is JMH .

Just as important as actual timings, but often related to taking meaningful timings, is measuring algorithm space and time complexity . This allows you to understand how your algorithm will grow as the input dataset changes in size. For example MethodA might be faster on a small input array and impractically slow on an input array 100x bigger, whereas MethodB may take the same time regardless of array size.

If you want to find out where in a program you should start looking to improve performance you can use a profiler ( eg eclipse.org: An introduction to profiling Java applications ). This will help you identify things such as: high memory usage, high GC usage, total method time (eg low method call count but high execution time, or high call count and small but significant execution time). However profilers will impact on your program's execution time as well.

TL;DR: profiling and performance testing is hard. Often you aren't really measuring what you think you are measuring.

Answer 2

long startTime = System.nanoTime();
methodOne();
long endTime = System.nanoTime();
long duration = (endTime - startTime);

You as a programmer should be more interested in complexity (Usually Time Complexity, but sometimes you should also worry about Space Complexity) of your algorithm rather than actual time taken to execute the program. Have a read here about analysing algorithm complexity