How can I count the time it takes a function to complete in Java?

I need to measure the time it takes for a function to complete in Java. How can I do that?

Note:

I want to measure the function's time consumption, not that of the full program.

long start = System.nanoTime();    
methodToBeTimed();
long elapsedTime = System.nanoTime() - start;

Here is how can compute the elapsed time.

// Get current time
long start = System.currentTimeMillis();
   
// Do something ...
   
// Get elapsed time in milliseconds
long elapsedTimeMillis = System.currentTimeMillis()-start;
   
// Get elapsed time in seconds
float elapsedTimeSec = elapsedTimeMillis/1000F;
   
// Get elapsed time in minutes
float elapsedTimeMin = elapsedTimeMillis/(60*1000F);
   
// Get elapsed time in hours
float elapsedTimeHour = elapsedTimeMillis/(60*60*1000F);
   
// Get elapsed time in days
float elapsedTimeDay = elapsedTimeMillis/(24*60*60*1000F);

If you are using Guava, consider using the Stopwatch, e.g.:

final Stopwatch sw = Stopwatch.createStarted();
methodToBeTimed();
final long elapsedMillis = sw.elapsed(TimeUnit.MILLISECONDS);

Use a profiler.

The profiler is the right answer if you have more than one function.

Another problem that I see with all the suggestions given so far is that they work fine for a single function, but your code will be littered with timing stuff that you can't turn off.

If you know how to do aspect oriented programming, it's a good way to keep the timing code in one place and apply it declaratively. If you use something like Log4J to output the values, you'll have the option of turning it off or on. It's a poor man's profiler.

Have a look at AspectJ or Spring's AOP.

All of the code snippets above measure the approximate time elapsed from the time the method was invoked to the time the method returns/throws an exception. Such techniques do not address thread scheduling, pauses due the GC, etc.

Yes, some profilers will do a reasonable job.

If you are using Java 1.6 onwards, you can use the JMX based VM management and monitoring support. For example, you may find ThreadMXBean.getCurrentThreadCpuTime() of value. Calculating the difference of this value before and after the method invoke will give you:

> "... the total CPU time for the current thread in nanoseconds. The returned value is of nanoseconds precision but not necessarily nanoseconds accuracy. If the implementation distinguishes between user mode time and system mode time, the returned CPU time is the amount of time that the current thread has executed in user mode or system mode."

If your method spawns off worker threads, then your computation will need to get far more elaborate ;-)

In general, I recommend nosing around the java.lang.mangement package.

System.nanoTime should be used to accurately measure the delta between two times for microbenchmarks.

public class CountTime {

  private static void walk() {
    for (int i = 0; i < Integer.MAX_VALUE; i++)
      ;
  }

  public static void main(String[] args) {
    long t0 = System.nanoTime();
    walk();
    long t1 = System.nanoTime();
    System.out.println("Elapsed time =" + (t1 - t0)
        + " nanoseconds");
  }

}

System.currentTimeMillis returns the current time in milliseconds. You can use this to get the current time. This may be useful on older VMs or for longer running processes.

Use either System.currentTimeMillis() or System.nanoTime():

int someMethod() {
    long tm = System.nanoTime();
    try {
        ...
    } finally {
        tm = System.nanoTime()-tm;
        System.out.println("time spent in someMethod(): " + tm + "ns");
    }
}

this analogue stopwatch is another option for us too... Check on Java2s.com here.

If you want to get current time, use java.util.Date.