Measure elapsed time (or execution time) in Java
This post will discuss how to measure elapsed time in Java using System.nanoTime(), System.currentTimeMillis(), Instant.now() and StopWatch provided by Guava and Apache Commons Lang.
1. Using System.nanoTime() method
We can use System.nanoTime() to measure elapsed time with nanosecond precision. It returns the current value of the running JVM’s high-resolution time source in nanoseconds.
The value returned by this method has no meaning on its own, but it can become meaningful when the difference between two such values is computed.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { long startTime = System.nanoTime(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ long endTime = System.nanoTime(); // get the difference between the two nano time valuess long timeElapsed = endTime - startTime; System.out.println("Execution time in nanoseconds: " + timeElapsed); System.out.println("Execution time in milliseconds: " + timeElapsed / 1000000); } } |
Output (may vary):
Execution time in nanoseconds : 5000372657
Execution time in milliseconds: 5000
2. Using System.currentTimeMillis() method
Java System class also provides the static method currentTimeMillis() that returns the difference between the current time and midnight, January 1, 1970, UTC, in milliseconds.
Ideally, currentTimeMillis() should be used to measure wall-clock time, and nanoTime() should measure the program’s elapsed time. If the elapsed time is measured with System.currentTimeMillis(), the results might not be accurate.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { long startTime = System.currentTimeMillis(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ long endTime = System.currentTimeMillis(); long timeElapsed = endTime - startTime; System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5001
3. Using Instant.now() method
Instant class can be used to record event time-stamps in the application. It has now() method that obtains the current instant from the system clock. We can convert this instant to the total number of milliseconds using toEpochMilli() method.
Please note that Instant.now() internally use System.currentTimeMillis() and might not be the best solution to measure elapsed time.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.time.Instant; import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { long startTime = Instant.now().toEpochMilli(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ long endTime = Instant.now().toEpochMilli(); long timeElapsed = endTime - startTime; System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5001
We can also calculate the duration between two Instant using the Duration.between method that returns a Duration instance. Then we can get the total number of seconds in this duration using the getSeconds or get method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
import java.time.Duration; import java.time.Instant; import java.util.concurrent.TimeUnit; import static java.time.temporal.ChronoUnit.SECONDS; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { Instant start = Instant.now(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ Instant end = Instant.now(); Duration interval = Duration.between(start, end); System.out.println("Execution time in seconds: " + interval.getSeconds()); // System.out.println("Execution time in seconds: " + interval.get(SECONDS)); } } |
Output (may vary):
Execution time in seconds: 5
4. Using Guava’s StopWatch Class
We can also measure elapsed time using Guava’s StopWatch class instead of System.nanoTime() as StopWatch provides more abstraction by not exposing the absolute value returned by nanoTime(), which serves no importance. We can only get the relative values from the StopWatch.elapsed() method.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import com.google.common.base.Stopwatch; import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { // Creates and starts a new stopwatch Stopwatch stopwatch = Stopwatch.createStarted(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ stopwatch.stop(); // optional // get elapsed time, expressed in milliseconds long timeElapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS); System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5001
5. Using Apache Commons Lang
We can also use StopWatch API provided by Apache Commons Lang to measure execution time in milliseconds. To start the watch, simply call the start() or createStarted() method and then call getTime() to get the time between the start and the moment this method is called.
We can also call stop() method before getTime(), in that case getTime() returns the amount of time between start and stop.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import org.apache.commons.lang3.time.StopWatch; import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { StopWatch stopwatch = new StopWatch(); stopwatch.start(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ stopwatch.stop(); // Optional long timeElapsed = stopwatch.getTime(); System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5002
6. Using Date.getTime() method
We can also use the getTime() method provided by the Date class that returns the total number of milliseconds since January 1, 1970, GMT.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.util.Date; import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { long startTime = new Date().getTime(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ long endTime = new Date().getTime(); long timeElapsed = endTime - startTime; System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5001
7. Using Calendar API
The following code uses Java’s Calendar API, which is not recommended as it adds extra overhead for a simple task.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.util.Calendar; import java.util.concurrent.TimeUnit; // Program to measure elapsed time in Java class Main { public static void main(String[] args) throws InterruptedException { long startTime = Calendar.getInstance().getTime().getTime(); /* … The code being measured starts … */ // sleep for 5 seconds TimeUnit.SECONDS.sleep(5); /* … The code being measured ends … */ long endTime = Calendar.getInstance().getTime().getTime(); long timeElapsed = endTime - startTime; System.out.println("Execution time in milliseconds: " + timeElapsed); } } |
Output (may vary):
Execution time in milliseconds: 5013
That’s all about measuring elapsed time in Java.
Thanks for reading.
To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.
Like us? Refer us to your friends and support our growth. Happy coding :)