How do I time a method s execution in Java

Question

How do I get a method s execution time    Is there a Timer utility class for things like timing how long a task takes  etc      Most of the searches on Google return results for timers that schedule threads and tasks  which is not what I want

User · Answer

Using Instant and Duration from Java 8 s new API   Instant start   Instant now    Thread sleep 5000   Instant end   Instant now    System out println Duration between start  end      outputs   PT5S

User · Answer

We are using AspectJ and Java annotations for this purpose  If we need to know to execution time for a method  we simple annotate it  A more advanced version could use an own log level that can enabled and disabled at runtime   public  interface Trace     boolean showParameters        Aspect public class TraceAspect              Around  tracePointcut    amp  amp   annotation trace   amp  amp   within TraceAspect      public Object traceAdvice   ProceedingJintPoint jP  Trace trace          Object result         initilize timer      try          result   jp procced          finally             calculate execution time             return result

User · Answer

As  skaffman  said  use AOP OR you can use run time bytecode weaving  just like unit test method coverage tools use to transparently add timing info to methods invoked   You can look at code used by open source tools tools like Emma  http   downloads sourceforge net emma emma-2 0 5312-src zip modtime 1118607545 amp big mirror 0   The other opensource coverage tool is http   prdownloads sourceforge net cobertura cobertura-1 9-src zip download   If you eventually manage to do what you set out for  pls  share it back with the community here with your ant task jars

User · Answer

With Java 8 you can do also something like this with every normal methods   Object returnValue   TimeIt printTime    - gt  methodeWithReturnValue       do stuff with your returnValue   with TimeIt like   public class TimeIt    public static  lt T gt  T printTime Callable lt T gt  task        T call   null      try           long startTime   System currentTimeMillis            call   task call            System out print  System currentTimeMillis   - startTime    1000d    s          catch  Exception e                            return call        With this methode you can make easy time measurement anywhere in your code without breaking it  In this simple example i just print the time  May you add a Switch for TimeIt  e g  to only print the time in DebugMode or something   If you are working with Function you can do somthing like this   Function lt Integer  Integer gt  yourFunction   n  - gt            return IntStream range 0  n  reduce 0   a  b  - gt  a   b           Integer returnValue   TimeIt printTime2 yourFunction  apply 10000     do stuff with your returnValue  public static  lt T  R gt  Function lt T  R gt  printTime2 Function lt T  R gt  task        return  t  - gt            long startTime   System currentTimeMillis            R apply   task apply t           System out print  System currentTimeMillis   - startTime    1000d                    s            return apply

User · Answer

It would be nice if java had a better functional support  so that the action  that needs to be measured  could be wrapped into a block    measure         your operation here     In java this could be done by anonymous functions  that look too verbose  public interface Timer       void wrap        public class Logger        public static void logTime Timer timer            long start   System currentTimeMillis            timer wrap            System out println       System currentTimeMillis   - start     ms               public static void main String a              Logger logTime new Timer                 public void wrap                        Your method here                 timeConsumingOperation                                          public static void timeConsumingOperation             for  int i   0  i lt  10000  i                 System out println  i    i

User · Answer

You can use javaagent to modify the java class bytes  add the monitor codes dynamically there is some open source tools on the github that can do this for you  If you want to do it by yourself  just implements the javaagent use javassist to modify the methods you want to monitor and the monitor code before your method return it s clean and you can monitor systems that you even don t have source code

User · Answer

I go with the simple answer  Works for me   long startTime   System currentTimeMillis     doReallyLongThing     long endTime   System currentTimeMillis     System out println  That took      endTime - startTime      milliseconds      It works quite well  The resolution is obviously only to the millisecond  you can do better with System nanoTime    There are some limitations to both  operating system schedule slices  etc   but this works pretty well   Average across a couple of runs  the more the better  and you ll get a decent idea

User · Answer

This probably isn t what you wanted me to say  but this is a good use of AOP  Whip an proxy interceptor around your method  and do the timing in there   The what  why and how of AOP is rather beyond the scope of this answer  sadly  but that s how I d likely do it    Edit  Here s a link to Spring AOP to get you started  if you re keen  This is the most accessible implementation of AOP that Iive come across for java   Also  given everyone else s very simple suggestions  I should add that AOP is for when you don t want stuff like timing to invade your code  But in many cases  that sort of simple and easy approach is fine

User · Answer

You can use stopwatch class from spring core project    Code   StopWatch stopWatch   new StopWatch   stopWatch start       start stopwatch    write your function or line of code  stopWatch stop       stop stopwatch stopWatch getTotalTimeMillis        get total time   Documentation for Stopwatch  Simple stop watch  allowing for timing of a number of tasks  exposing total running time and running time for each named task   Conceals use of System currentTimeMillis    improving the readability of application code and reducing the likelihood of calculation errors   Note that this object is not designed to be thread-safe and does not use synchronization   This class is normally used to verify performance during proof-of-concepts and in development  rather than as part of production applications

User · Answer

new Timer              code to time     timeMe       public class Timer        private final String timerName      private long started       public Timer String timerName            this timerName   timerName          this started   System currentTimeMillis               public void timeMe             System out println          String format  Execution of   s  takes  dms                     timerName                   started-System currentTimeMillis

User · Answer

There is always the old-fashioned way   long startTime   System nanoTime    methodToTime    long endTime   System nanoTime     long duration    endTime - startTime      divide by 1000000 to get milliseconds

User · Answer

Spring provides a utility class org springframework util StopWatch  as per JavaDoc      Simple stop watch  allowing for timing of a number of tasks  exposing   total running time and running time for each named task    Usage   StopWatch stopWatch   new StopWatch  Performance Test Result     stopWatch start  Method 1    doSomething1     method to test stopWatch stop     stopWatch start  Method 2    doSomething2     method to test stopWatch stop     System out println stopWatch prettyPrint       Output   StopWatch  Performance Test Result   running time  millis    12829 ----------------------------------------- ms           Task name ----------------------------------------- 11907  036   Method 1 00922  064   Method 2   With Aspects    Around  execution   my package             public Object logTime ProceedingJoinPoint joinPoint  throws Throwable       StopWatch stopWatch   new StopWatch        stopWatch start        Object retVal   joinPoint proceed        stopWatch stop        log info   execution time      stopWatch getTotalTimeMillis       ms        return retVal

User · Answer

There are a couple of ways to do that  I normally fall back to just using something like this    long start   System currentTimeMillis           do something     long end   System currentTimeMillis      or the same thing with System nanoTime     For something more on the benchmarking side of things there seems also to be this one  http   jetm void fm  Never tried it though

User · Answer

Use a profiler  JProfiler  Netbeans Profiler  Visual VM  Eclipse Profiler  etc   You ll get the most accurate results and is the least intrusive  They use the built-in JVM mechanism for profiling which can also give you extra information like stack traces  execution paths  and more comprehensive results if necessary   When using a fully integrated profiler  it s faily trivial to profile a method  Right click  Profiler -  Add to Root Methods  Then run the profiler just like you were doing a test run or debugger

User · Answer

We are using AspectJ and Java annotations for this purpose  If we need to know to execution time for a method  we simple annotate it  A more advanced version could use an own log level that can enabled and disabled at runtime   public  interface Trace     boolean showParameters        Aspect public class TraceAspect              Around  tracePointcut    amp  amp   annotation trace   amp  amp   within TraceAspect      public Object traceAdvice   ProceedingJintPoint jP  Trace trace          Object result         initilize timer      try          result   jp procced          finally             calculate execution time             return result

User · Answer

You can use Perf4j  Very cool utility  Usage is simple  String watchTag    target SomeMethod   StopWatch stopWatch   new LoggingStopWatch watchTag   Result result   null     Result is a type of a return value of a method try       result   target SomeMethod        stopWatch stop watchTag     success      catch  Exception e        stopWatch stop watchTag     fail    Exception was     e       throw e       More information can be found in Developer Guide  Edit  Project seems dead

User · Answer

You can use javaagent to modify the java class bytes  add the monitor codes dynamically there is some open source tools on the github that can do this for you  If you want to do it by yourself  just implements the javaagent use javassist to modify the methods you want to monitor and the monitor code before your method return it s clean and you can monitor systems that you even don t have source code

User · Answer

I implemented a simple timer  And I think it s really useful   public class Timer      private static long start time       public static double tic            return start time   System nanoTime               public static double toc            return  System nanoTime  -start time  1000000000 0             That way you can time one or more actions   Timer tic       Code 1 System out println  Code 1 runtime    Timer toc     seconds        Code 2 System out println   Code 1   Code 2  runtime    Timer toc    seconds    Timer tic       Code 3 System out println  Code 3 runtime    Timer toc     seconds

User · Answer

Using AOP AspectJ and  Loggable annotation from jcabi-aspects you can do it easy and compact    Loggable Loggable DEBUG  public String getSomeResult          return some value     Every call to this method will be sent to SLF4J logging facility with DEBUG logging level  And every log message will include execution time

User · Answer

I modified the code from correct answer to get result in seconds    long startTime   System nanoTime     methodCode      long endTime   System nanoTime    double duration    double  endTime - startTime     Math pow 10  9    Log v TAG   MethodName time  s        duration

User · Answer

Just a small twist  if you don t use tooling and want to time methods with low execution time  execute it many times  each time doubling the number of times it is executed until you reach a second  or so  Thus  the time of the Call to System nanoTime and so forth  nor the accuracy of System nanoTime does affect the result much       int runs   0  runsPerRound   10      long begin   System nanoTime    end      do           for  int i 0  i lt runsPerRound    i  timedMethod            end   System nanoTime            runs    runsPerRound          runsPerRound    2        while  runs  lt  Integer MAX VALUE   2  amp  amp  1000000000L  gt  end - begin       System out println  Time for timedMethod   is              0 000000001    end-begin    runs     seconds      Of course  the caveats about using the wall clock apply  influences of JIT-compilation  multiple threads   processes etc  Thus  you need to first execute the method a lot of times first  such that the JIT compiler does its work  and then repeat this test multiple times and take the lowest execution time

User · Answer

There are a couple of ways to do that  I normally fall back to just using something like this    long start   System currentTimeMillis           do something     long end   System currentTimeMillis      or the same thing with System nanoTime     For something more on the benchmarking side of things there seems also to be this one  http   jetm void fm  Never tried it though

User · Answer

Really good code   http   www rgagnon com javadetails java-0585 html  import java util concurrent TimeUnit   long startTime   System currentTimeMillis                               long finishTime   System currentTimeMillis     String diff   millisToShortDHMS finishTime - startTime                converts time  in milliseconds  to human-readable format         lt dd  gt hh mm ss          public static String millisToShortDHMS long duration        String res           long days    TimeUnit MILLISECONDS toDays duration       long hours   TimeUnit MILLISECONDS toHours duration                     - TimeUnit DAYS toHours TimeUnit MILLISECONDS toDays duration        long minutes   TimeUnit MILLISECONDS toMinutes duration                       - TimeUnit HOURS toMinutes TimeUnit MILLISECONDS toHours duration        long seconds   TimeUnit MILLISECONDS toSeconds duration                     - TimeUnit MINUTES toSeconds TimeUnit MILLISECONDS toMinutes duration        if  days    0          res   String format   02d  02d  02d   hours  minutes  seconds             else         res   String format   dd 02d  02d  02d   days  hours  minutes  seconds             return res

User · Answer

You can use Metrics library which provides various measuring instruments  Add dependency    lt dependencies gt       lt dependency gt           lt groupId gt io dropwizard metrics lt  groupId gt           lt artifactId gt metrics-core lt  artifactId gt           lt version gt   metrics version  lt  version gt       lt  dependency gt   lt  dependencies gt    And configure it for your environment    Methods can be annotated with  Timed    Timed public void exampleMethod           some code     or piece of code wrapped with Timer   final Timer timer   metricsRegistry timer  some name    final Timer Context context   timer time       timed code context stop      Aggregated metrics can exported to console  JMX  CSV or other    Timed metrics output example   com example ExampleService exampleMethod              count   2          mean rate   3 11 calls minute      1-minute rate   0 96 calls minute      5-minute rate   0 20 calls minute     15-minute rate   0 07 calls minute                min   17 01 milliseconds                max   1006 68 milliseconds               mean   511 84 milliseconds             stddev   699 80 milliseconds             median   511 84 milliseconds               75   lt   1006 68 milliseconds               95   lt   1006 68 milliseconds               98   lt   1006 68 milliseconds               99   lt   1006 68 milliseconds             99 9   lt   1006 68 milliseconds

User · Answer

If you want wall-clock time  long start time   System currentTimeMillis    object method    long end time   System currentTimeMillis    long execution time   end time - start time

User · Answer

In Java 8 a new class named Instant is introduced  As per doc      Instant represents the start of a nanosecond on the time line  This   class is useful for generating a time stamp to represent machine time    The range of an instant requires the storage of a number larger than a   long  To achieve this  the class stores a long representing   epoch-seconds and an int representing nanosecond-of-second  which will   always be between 0 and 999 999 999  The epoch-seconds are measured   from the standard Java epoch of 1970-01-01T00 00 00Z where instants   after the epoch have positive values  and earlier instants have   negative values  For both the epoch-second and nanosecond parts  a   larger value is always later on the time-line than a smaller value    This can be used as   Instant start   Instant now    try       Thread sleep 7000     catch  InterruptedException e        e printStackTrace      Instant end   Instant now    System out println Duration between start  end      It prints PT7 001S

User · Answer

System currentTimeMillis    IS NOT a good approach for measuring the performance of your algorithms  It measures the total time you experience as a user watching the computer screen  It includes also time consumed by everything else running on your computer in the background  This could make a huge difference in case you have a lot of programs running on your workstation   Proper approach is  using java lang management package   From http   nadeausoftware com articles 2008 03 java tip how get cpu and user time benchmarking website  archive link      User time  is the time spent running your application s own code   System time  is the time spent running OS code on behalf of your application  such as for I O     getCpuTime   method gives you sum of those   import java lang management ManagementFactory  import java lang management ThreadMXBean   public class CPUUtils            Get CPU time in nanoseconds         public static long getCpuTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                  bean getCurrentThreadCpuTime      0L                 Get user time in nanoseconds         public static long getUserTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                  bean getCurrentThreadUserTime      0L                 Get system time in nanoseconds         public static long getSystemTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                   bean getCurrentThreadCpuTime    - bean getCurrentThreadUserTime       0L

User · Answer

System nanoTime   is a pretty precise system utility to measure execution time  But be careful  if you re running on pre-emptive scheduler mode  default   this utility actually measures wall-clock time and not CPU time  Therefore  you may notice different execution time values from run to run  depending on system loads  If you look for CPU time  I think that running your program in real-time mode will do the trick  You have to use RT linux  link  Real-time programming with Linux

User · Answer

Pure Java SE code  no need for adding dependency  using TimeTracedExecuter    public static void main String   args         Integer square   new TimeTracedExecutor lt  gt  Main  calculateSquare                   executeWithInput  calculate square of num  5 logger      public static int calculateSquare int num       return num num      Will produce result like this   INFO  It took 3 milliseconds to calculate square of num  Custom reusable class  TimeTracedExecutor  import java text NumberFormat  import java time Duration  import java time Instant  import java util function Function  import java util logging Logger   public class TimeTracedExecutor lt T R gt        Function lt T R gt  methodToExecute       public TimeTracedExecutor Function lt T  R gt  methodToExecute            this methodToExecute   methodToExecute             public R executeWithInput String taskDescription  T t  Logger logger           Instant start   Instant now            R r  methodToExecute apply t           Instant finish   Instant now            String format    It took  s milliseconds to   taskDescription          String elapsedTime   NumberFormat getNumberInstance   format Duration between start  finish  toMillis             logger info String format format  elapsedTime            return r

User · Answer

I basically do variations of this  but considering how hotspot compilation works  if you want to get accurate results you need to throw out the first few measurements and make sure you are using the method in a real world  read application specific  application     If the JIT decides to compile it your numbers will vary heavily   so just be aware

User · Answer

Use a profiler  JProfiler  Netbeans Profiler  Visual VM  Eclipse Profiler  etc   You ll get the most accurate results and is the least intrusive  They use the built-in JVM mechanism for profiling which can also give you extra information like stack traces  execution paths  and more comprehensive results if necessary   When using a fully integrated profiler  it s faily trivial to profile a method  Right click  Profiler -  Add to Root Methods  Then run the profiler just like you were doing a test run or debugger

User · Answer

As  skaffman  said  use AOP OR you can use run time bytecode weaving  just like unit test method coverage tools use to transparently add timing info to methods invoked   You can look at code used by open source tools tools like Emma  http   downloads sourceforge net emma emma-2 0 5312-src zip modtime 1118607545 amp big mirror 0   The other opensource coverage tool is http   prdownloads sourceforge net cobertura cobertura-1 9-src zip download   If you eventually manage to do what you set out for  pls  share it back with the community here with your ant task jars

User · Answer

In Java 8 a new class named Instant is introduced  As per doc      Instant represents the start of a nanosecond on the time line  This   class is useful for generating a time stamp to represent machine time    The range of an instant requires the storage of a number larger than a   long  To achieve this  the class stores a long representing   epoch-seconds and an int representing nanosecond-of-second  which will   always be between 0 and 999 999 999  The epoch-seconds are measured   from the standard Java epoch of 1970-01-01T00 00 00Z where instants   after the epoch have positive values  and earlier instants have   negative values  For both the epoch-second and nanosecond parts  a   larger value is always later on the time-line than a smaller value    This can be used as   Instant start   Instant now    try       Thread sleep 7000     catch  InterruptedException e        e printStackTrace      Instant end   Instant now    System out println Duration between start  end      It prints PT7 001S

User · Answer

Just a small twist  if you don t use tooling and want to time methods with low execution time  execute it many times  each time doubling the number of times it is executed until you reach a second  or so  Thus  the time of the Call to System nanoTime and so forth  nor the accuracy of System nanoTime does affect the result much       int runs   0  runsPerRound   10      long begin   System nanoTime    end      do           for  int i 0  i lt runsPerRound    i  timedMethod            end   System nanoTime            runs    runsPerRound          runsPerRound    2        while  runs  lt  Integer MAX VALUE   2  amp  amp  1000000000L  gt  end - begin       System out println  Time for timedMethod   is              0 000000001    end-begin    runs     seconds      Of course  the caveats about using the wall clock apply  influences of JIT-compilation  multiple threads   processes etc  Thus  you need to first execute the method a lot of times first  such that the JIT compiler does its work  and then repeat this test multiple times and take the lowest execution time

User · Answer

I have written a method to print the method execution time in a much readable form  For example  to calculate the factorial of 1 Million  it takes approximately 9 minutes  So the execution time get printed as   Execution Time  9 Minutes  36 Seconds  237 MicroSeconds  806193 NanoSeconds   The code is here   public class series       public static void main String   args                long startTime   System nanoTime             long n   10 00 000          printFactorial n            long endTime   System nanoTime            printExecutionTime startTime  endTime               public static void printExecutionTime long startTime  long endTime                long time ns   endTime - startTime          long time ms   TimeUnit NANOSECONDS toMillis time ns           long time sec   TimeUnit NANOSECONDS toSeconds time ns           long time min   TimeUnit NANOSECONDS toMinutes time ns           long time hour   TimeUnit NANOSECONDS toHours time ns            System out print   nExecution Time              if time hour  gt  0              System out print time hour     Hours              if time min  gt  0              System out print time min   60     Minutes              if time sec  gt  0              System out print time sec   60     Seconds              if time ms  gt  0              System out print time ms   1E 3     MicroSeconds              if time ns  gt  0              System out print time ns   1E 6     NanoSeconds

User · Answer

Also We can use StopWatch class of Apache commons for measuring the time   Sample code  org apache commons lang time StopWatch sw   new org apache commons lang time StopWatch     System out println  getEventFilterTreeData    Start Time       sw getTime     sw start        Method execution code  sw stop    System out println  getEventFilterTreeData    End Time       sw getTime

User · Answer

We are using AspectJ and Java annotations for this purpose  If we need to know to execution time for a method  we simple annotate it  A more advanced version could use an own log level that can enabled and disabled at runtime   public  interface Trace     boolean showParameters        Aspect public class TraceAspect              Around  tracePointcut    amp  amp   annotation trace   amp  amp   within TraceAspect      public Object traceAdvice   ProceedingJintPoint jP  Trace trace          Object result         initilize timer      try          result   jp procced          finally             calculate execution time             return result

User · Answer

For java 8   another possible solution  more general  func-style and without aspects  could be to create some utility method accepting code as a parameter    public static  lt T gt  T timed  String description  Consumer lt String gt  out  Supplier lt T gt  code        final LocalDateTime start   LocalDateTime now         T res   code get         final long execTime   Duration between  start  LocalDateTime now     toMillis         out accept  String format    s   d ms   description  execTime        return res      And the calling code could be smth like that   public static void main  String   args  throws InterruptedException       timed   Simple example   System out  println  Timing  myCode      public static Object myCode          try           Thread sleep  1500         catch  InterruptedException e            e printStackTrace               return null

User · Answer

You can use stopwatch class from spring core project    Code   StopWatch stopWatch   new StopWatch   stopWatch start       start stopwatch    write your function or line of code  stopWatch stop       stop stopwatch stopWatch getTotalTimeMillis        get total time   Documentation for Stopwatch  Simple stop watch  allowing for timing of a number of tasks  exposing total running time and running time for each named task   Conceals use of System currentTimeMillis    improving the readability of application code and reducing the likelihood of calculation errors   Note that this object is not designed to be thread-safe and does not use synchronization   This class is normally used to verify performance during proof-of-concepts and in development  rather than as part of production applications

User · Answer

Performance measurements on my machine  System nanoTime     750ns System currentTimeMillis     18ns  As mentioned  System nanoTime   is thought to measure elapsed time  Just be aware of the cost if used inside a loop or the like

User · Answer

I modified the code from correct answer to get result in seconds    long startTime   System nanoTime     methodCode      long endTime   System nanoTime    double duration    double  endTime - startTime     Math pow 10  9    Log v TAG   MethodName time  s        duration

User · Answer

If you want wall-clock time  long start time   System currentTimeMillis    object method    long end time   System currentTimeMillis    long execution time   end time - start time

User · Answer

There are a couple of ways to do that  I normally fall back to just using something like this    long start   System currentTimeMillis           do something     long end   System currentTimeMillis      or the same thing with System nanoTime     For something more on the benchmarking side of things there seems also to be this one  http   jetm void fm  Never tried it though

User · Answer

Pure Java SE code  no need for adding dependency  using TimeTracedExecuter    public static void main String   args         Integer square   new TimeTracedExecutor lt  gt  Main  calculateSquare                   executeWithInput  calculate square of num  5 logger      public static int calculateSquare int num       return num num      Will produce result like this   INFO  It took 3 milliseconds to calculate square of num  Custom reusable class  TimeTracedExecutor  import java text NumberFormat  import java time Duration  import java time Instant  import java util function Function  import java util logging Logger   public class TimeTracedExecutor lt T R gt        Function lt T R gt  methodToExecute       public TimeTracedExecutor Function lt T  R gt  methodToExecute            this methodToExecute   methodToExecute             public R executeWithInput String taskDescription  T t  Logger logger           Instant start   Instant now            R r  methodToExecute apply t           Instant finish   Instant now            String format    It took  s milliseconds to   taskDescription          String elapsedTime   NumberFormat getNumberInstance   format Duration between start  finish  toMillis             logger info String format format  elapsedTime            return r

User · Answer

Here is pretty printed string ready formated seconds elapsed similar to google search time took to search           long startTime   System nanoTime                    methodToTime            long endTime   System nanoTime            long duration    endTime - startTime           long seconds    duration   1000    60             formatedSeconds    0 xy seconds          String formatedSeconds   String format   0  d seconds    seconds           System out println  formatedSeconds      formatedSeconds              i e actual formatedSeconds    0 52 seconds

User · Answer

Gathered all possible ways together into one place   Date  Date startDate   Calendar getInstance   getTime    long d StartTime   new Date   getTime    Thread sleep 1000   4   Date endDate   Calendar getInstance   getTime    long d endTime   new Date   getTime    System out format  StartDate    s  EndDate    s  n   startDate  endDate   System out format  Milli    s    D Start    s  D End    s    n    d endTime - d StartTime  d StartTime  d endTime     System currentTimeMillis    long startTime   System currentTimeMillis    Thread sleep 1000   4   long endTime   System currentTimeMillis    long duration    endTime - startTime     System out format  Milli    s    S Start    s  S End    s    n   duration  startTime  endTime    System out println  Human-Readable format     millisToShortDHMS  duration        Human Readable Format  public static String millisToShortDHMS long duration        String res             java util concurrent TimeUnit      long days         TimeUnit MILLISECONDS toDays duration       long hours        TimeUnit MILLISECONDS toHours duration  -                       TimeUnit DAYS toHours TimeUnit MILLISECONDS toDays duration        long minutes      TimeUnit MILLISECONDS toMinutes duration  -                       TimeUnit HOURS toMinutes TimeUnit MILLISECONDS toHours duration        long seconds      TimeUnit MILLISECONDS toSeconds duration  -                       TimeUnit MINUTES toSeconds TimeUnit MILLISECONDS toMinutes duration        long millis       TimeUnit MILLISECONDS toMillis duration  -                        TimeUnit SECONDS toMillis TimeUnit MILLISECONDS toSeconds duration         if  days    0       res   String format   02d  02d  02d  04d   hours  minutes  seconds  millis       else                res   String format   dd  02d  02d  02d  04d   days  hours  minutes  seconds  millis       return res      Guava  Google StopwatchJAR    An object of Stopwatch is to measures elapsed time in nanoseconds   com google common base Stopwatch g SW   Stopwatch createUnstarted    g SW start    Thread sleep 1000   4   g SW stop    System out println  Google StopWatch      g SW     Apache Commons LangJAR     StopWatch provides a convenient API for timings   org apache commons lang3 time StopWatch sw   new StopWatch    sw start         Thread sleep 1000   4        sw stop    System out println  Apache StopWatch       millisToShortDHMS sw getTime         JODA-TIME  public static void jodaTime   throws InterruptedException  ParseException      java text SimpleDateFormat ms SDF   new SimpleDateFormat  yyyy MM dd HH mm ss SSS        String start   ms SDF format  new Date         java util Date      Thread sleep 10000        String end   ms SDF format  new Date                 System out println  Start   start   t Stop   end        Date date 1   ms SDF parse start       Date date 2   ms SDF parse end               Interval interval   new org joda time Interval  date 1 getTime    date 2 getTime          Period period   interval toPeriod      org joda time Period      System out format   dY  dM  dD   02d  02d  02d  04d  n            period getYears    period getMonths    period getDays            period getHours    period getMinutes    period getSeconds    period getMillis         Java date time API from Java 8    A Duration object represents a period of time between two Instant objects   Instant start   java time Instant now        Thread sleep 1000   Instant end   java time Instant now    Duration between   java time Duration between start  end   System out println  between       PT1 001S System out format   dD   02d  02d  02d  04d  n   between toDays            between toHours    between toMinutes    between getSeconds    between toMillis        0D  00 00 01 1001      Spring Framework provides StopWatch utility class to measure elapsed time in Java     StopWatch sw   new org springframework util StopWatch    sw start  Method-1       Start a named task     Thread sleep 500   sw stop     sw start  Method-2        Thread sleep 300   sw stop     sw start  Method-3        Thread sleep 200   sw stop     System out println  Total time in milliseconds for all tasks   n  sw getTotalTimeMillis     System out println  Table describing all tasks performed   n  sw prettyPrint      System out format  Time taken by the last task     s    d             sw getLastTaskName   sw getLastTaskTimeMillis      System out println   n Array of the data for tasks performed    Task Name  Time Taken    TaskInfo   listofTasks   sw getTaskInfo    for  TaskInfo task   listofTasks        System out format    s    d  n                task getTaskName    task getTimeMillis           OutPut   Total time in milliseconds for all tasks   999 Table describing all tasks performed   StopWatch     running time  millis    999 ----------------------------------------- ms           Task name ----------------------------------------- 00500  050   Method-1 00299  030   Method-2 00200  020   Method-3  Time taken by the last task    Method-3   200   Array of the data for tasks performed    Task Name  Time Taken  Method-1   500   Method-2   299   Method-3   200

User · Answer

JEP 230  Microbenchmark Suite  FYI  JEP 230  Microbenchmark Suite is an OpenJDK project to      Add a basic suite of microbenchmarks to the JDK source code  and make it easy for developers to run existing microbenchmarks and create new ones    This feature arrived in Java 12   Java Microbenchmark Harness  JMH   For earlier versions of Java  take a look at the Java Microbenchmark Harness  JMH  project on which JEP 230 is based

User · Answer

This probably isn t what you wanted me to say  but this is a good use of AOP  Whip an proxy interceptor around your method  and do the timing in there   The what  why and how of AOP is rather beyond the scope of this answer  sadly  but that s how I d likely do it    Edit  Here s a link to Spring AOP to get you started  if you re keen  This is the most accessible implementation of AOP that Iive come across for java   Also  given everyone else s very simple suggestions  I should add that AOP is for when you don t want stuff like timing to invade your code  But in many cases  that sort of simple and easy approach is fine

User · Answer

Use a profiler  JProfiler  Netbeans Profiler  Visual VM  Eclipse Profiler  etc   You ll get the most accurate results and is the least intrusive  They use the built-in JVM mechanism for profiling which can also give you extra information like stack traces  execution paths  and more comprehensive results if necessary   When using a fully integrated profiler  it s faily trivial to profile a method  Right click  Profiler -  Add to Root Methods  Then run the profiler just like you were doing a test run or debugger

User · Answer

For java 8   another possible solution  more general  func-style and without aspects  could be to create some utility method accepting code as a parameter    public static  lt T gt  T timed  String description  Consumer lt String gt  out  Supplier lt T gt  code        final LocalDateTime start   LocalDateTime now         T res   code get         final long execTime   Duration between  start  LocalDateTime now     toMillis         out accept  String format    s   d ms   description  execTime        return res      And the calling code could be smth like that   public static void main  String   args  throws InterruptedException       timed   Simple example   System out  println  Timing  myCode      public static Object myCode          try           Thread sleep  1500         catch  InterruptedException e            e printStackTrace               return null

User · Answer

new Timer              code to time     timeMe       public class Timer        private final String timerName      private long started       public Timer String timerName            this timerName   timerName          this started   System currentTimeMillis               public void timeMe             System out println          String format  Execution of   s  takes  dms                     timerName                   started-System currentTimeMillis

User · Answer

A strategy that works to me in java ee was    Create a class with a method annotated with  AroundInvoke    Singleton public class TimedInterceptor implements Serializable         AroundInvoke     public Object logMethod InvocationContext ic  throws Exception           Date start   new Date            Object result   ic proceed            Date end   new Date            System out println  time       end getTime - start getTime              return result           Annotate the method that you want to monitoring    Interceptors TimedInterceptor class  public void onMessage final Message message            I hope this can help

User · Answer

In Spring framework we have a call called StopWatch  org springframework util StopWatch     measuring elapsed time using Spring StopWatch         StopWatch watch   new StopWatch            watch start            for int i 0  i lt  1000  i                 Object obj   new Object                      watch stop            System out println  Total execution time to create 1000 objects in Java using StopWatch in millis                      watch getTotalTimeMillis

User · Answer

A strategy that works to me in java ee was    Create a class with a method annotated with  AroundInvoke    Singleton public class TimedInterceptor implements Serializable         AroundInvoke     public Object logMethod InvocationContext ic  throws Exception           Date start   new Date            Object result   ic proceed            Date end   new Date            System out println  time       end getTime - start getTime              return result           Annotate the method that you want to monitoring    Interceptors TimedInterceptor class  public void onMessage final Message message            I hope this can help

User · Answer

Use a profiler  JProfiler  Netbeans Profiler  Visual VM  Eclipse Profiler  etc   You ll get the most accurate results and is the least intrusive  They use the built-in JVM mechanism for profiling which can also give you extra information like stack traces  execution paths  and more comprehensive results if necessary   When using a fully integrated profiler  it s faily trivial to profile a method  Right click  Profiler -  Add to Root Methods  Then run the profiler just like you were doing a test run or debugger

User · Answer

System nanoTime   is a pretty precise system utility to measure execution time  But be careful  if you re running on pre-emptive scheduler mode  default   this utility actually measures wall-clock time and not CPU time  Therefore  you may notice different execution time values from run to run  depending on system loads  If you look for CPU time  I think that running your program in real-time mode will do the trick  You have to use RT linux  link  Real-time programming with Linux

User · Answer

In Spring framework we have a call called StopWatch  org springframework util StopWatch     measuring elapsed time using Spring StopWatch         StopWatch watch   new StopWatch            watch start            for int i 0  i lt  1000  i                 Object obj   new Object                      watch stop            System out println  Total execution time to create 1000 objects in Java using StopWatch in millis                      watch getTotalTimeMillis

User · Answer

You can try this way if just want know the time       long startTime   System currentTimeMillis        Method call System out println  Total time  ms        System currentTimeMillis   - startTime

User · Answer

I go with the simple answer  Works for me   long startTime   System currentTimeMillis     doReallyLongThing     long endTime   System currentTimeMillis     System out println  That took      endTime - startTime      milliseconds      It works quite well  The resolution is obviously only to the millisecond  you can do better with System nanoTime    There are some limitations to both  operating system schedule slices  etc   but this works pretty well   Average across a couple of runs  the more the better  and you ll get a decent idea

User · Answer

There is always the old-fashioned way   long startTime   System nanoTime    methodToTime    long endTime   System nanoTime     long duration    endTime - startTime      divide by 1000000 to get milliseconds

User · Answer

Just a small twist  if you don t use tooling and want to time methods with low execution time  execute it many times  each time doubling the number of times it is executed until you reach a second  or so  Thus  the time of the Call to System nanoTime and so forth  nor the accuracy of System nanoTime does affect the result much       int runs   0  runsPerRound   10      long begin   System nanoTime    end      do           for  int i 0  i lt runsPerRound    i  timedMethod            end   System nanoTime            runs    runsPerRound          runsPerRound    2        while  runs  lt  Integer MAX VALUE   2  amp  amp  1000000000L  gt  end - begin       System out println  Time for timedMethod   is              0 000000001    end-begin    runs     seconds      Of course  the caveats about using the wall clock apply  influences of JIT-compilation  multiple threads   processes etc  Thus  you need to first execute the method a lot of times first  such that the JIT compiler does its work  and then repeat this test multiple times and take the lowest execution time

User · Answer

You can try this way if just want know the time       long startTime   System currentTimeMillis        Method call System out println  Total time  ms        System currentTimeMillis   - startTime

User · Answer

With Java 8 you can do also something like this with every normal methods   Object returnValue   TimeIt printTime    - gt  methodeWithReturnValue       do stuff with your returnValue   with TimeIt like   public class TimeIt    public static  lt T gt  T printTime Callable lt T gt  task        T call   null      try           long startTime   System currentTimeMillis            call   task call            System out print  System currentTimeMillis   - startTime    1000d    s          catch  Exception e                            return call        With this methode you can make easy time measurement anywhere in your code without breaking it  In this simple example i just print the time  May you add a Switch for TimeIt  e g  to only print the time in DebugMode or something   If you are working with Function you can do somthing like this   Function lt Integer  Integer gt  yourFunction   n  - gt            return IntStream range 0  n  reduce 0   a  b  - gt  a   b           Integer returnValue   TimeIt printTime2 yourFunction  apply 10000     do stuff with your returnValue  public static  lt T  R gt  Function lt T  R gt  printTime2 Function lt T  R gt  task        return  t  - gt            long startTime   System currentTimeMillis            R apply   task apply t           System out print  System currentTimeMillis   - startTime    1000d                    s            return apply

User · Answer

Performance measurements on my machine  System nanoTime     750ns System currentTimeMillis     18ns  As mentioned  System nanoTime   is thought to measure elapsed time  Just be aware of the cost if used inside a loop or the like

User · Answer

I basically do variations of this  but considering how hotspot compilation works  if you want to get accurate results you need to throw out the first few measurements and make sure you are using the method in a real world  read application specific  application     If the JIT decides to compile it your numbers will vary heavily   so just be aware

User · Answer

I go with the simple answer  Works for me   long startTime   System currentTimeMillis     doReallyLongThing     long endTime   System currentTimeMillis     System out println  That took      endTime - startTime      milliseconds      It works quite well  The resolution is obviously only to the millisecond  you can do better with System nanoTime    There are some limitations to both  operating system schedule slices  etc   but this works pretty well   Average across a couple of runs  the more the better  and you ll get a decent idea

User · Answer

long startTime   System currentTimeMillis       code goes here long finishTime   System currentTimeMillis    long elapsedTime   finishTime - startTime     elapsed time in milliseconds

User · Answer

I basically do variations of this  but considering how hotspot compilation works  if you want to get accurate results you need to throw out the first few measurements and make sure you are using the method in a real world  read application specific  application     If the JIT decides to compile it your numbers will vary heavily   so just be aware

User · Answer

Gathered all possible ways together into one place   Date  Date startDate   Calendar getInstance   getTime    long d StartTime   new Date   getTime    Thread sleep 1000   4   Date endDate   Calendar getInstance   getTime    long d endTime   new Date   getTime    System out format  StartDate    s  EndDate    s  n   startDate  endDate   System out format  Milli    s    D Start    s  D End    s    n    d endTime - d StartTime  d StartTime  d endTime     System currentTimeMillis    long startTime   System currentTimeMillis    Thread sleep 1000   4   long endTime   System currentTimeMillis    long duration    endTime - startTime     System out format  Milli    s    S Start    s  S End    s    n   duration  startTime  endTime    System out println  Human-Readable format     millisToShortDHMS  duration        Human Readable Format  public static String millisToShortDHMS long duration        String res             java util concurrent TimeUnit      long days         TimeUnit MILLISECONDS toDays duration       long hours        TimeUnit MILLISECONDS toHours duration  -                       TimeUnit DAYS toHours TimeUnit MILLISECONDS toDays duration        long minutes      TimeUnit MILLISECONDS toMinutes duration  -                       TimeUnit HOURS toMinutes TimeUnit MILLISECONDS toHours duration        long seconds      TimeUnit MILLISECONDS toSeconds duration  -                       TimeUnit MINUTES toSeconds TimeUnit MILLISECONDS toMinutes duration        long millis       TimeUnit MILLISECONDS toMillis duration  -                        TimeUnit SECONDS toMillis TimeUnit MILLISECONDS toSeconds duration         if  days    0       res   String format   02d  02d  02d  04d   hours  minutes  seconds  millis       else                res   String format   dd  02d  02d  02d  04d   days  hours  minutes  seconds  millis       return res      Guava  Google StopwatchJAR    An object of Stopwatch is to measures elapsed time in nanoseconds   com google common base Stopwatch g SW   Stopwatch createUnstarted    g SW start    Thread sleep 1000   4   g SW stop    System out println  Google StopWatch      g SW     Apache Commons LangJAR     StopWatch provides a convenient API for timings   org apache commons lang3 time StopWatch sw   new StopWatch    sw start         Thread sleep 1000   4        sw stop    System out println  Apache StopWatch       millisToShortDHMS sw getTime         JODA-TIME  public static void jodaTime   throws InterruptedException  ParseException      java text SimpleDateFormat ms SDF   new SimpleDateFormat  yyyy MM dd HH mm ss SSS        String start   ms SDF format  new Date         java util Date      Thread sleep 10000        String end   ms SDF format  new Date                 System out println  Start   start   t Stop   end        Date date 1   ms SDF parse start       Date date 2   ms SDF parse end               Interval interval   new org joda time Interval  date 1 getTime    date 2 getTime          Period period   interval toPeriod      org joda time Period      System out format   dY  dM  dD   02d  02d  02d  04d  n            period getYears    period getMonths    period getDays            period getHours    period getMinutes    period getSeconds    period getMillis         Java date time API from Java 8    A Duration object represents a period of time between two Instant objects   Instant start   java time Instant now        Thread sleep 1000   Instant end   java time Instant now    Duration between   java time Duration between start  end   System out println  between       PT1 001S System out format   dD   02d  02d  02d  04d  n   between toDays            between toHours    between toMinutes    between getSeconds    between toMillis        0D  00 00 01 1001      Spring Framework provides StopWatch utility class to measure elapsed time in Java     StopWatch sw   new org springframework util StopWatch    sw start  Method-1       Start a named task     Thread sleep 500   sw stop     sw start  Method-2        Thread sleep 300   sw stop     sw start  Method-3        Thread sleep 200   sw stop     System out println  Total time in milliseconds for all tasks   n  sw getTotalTimeMillis     System out println  Table describing all tasks performed   n  sw prettyPrint      System out format  Time taken by the last task     s    d             sw getLastTaskName   sw getLastTaskTimeMillis      System out println   n Array of the data for tasks performed    Task Name  Time Taken    TaskInfo   listofTasks   sw getTaskInfo    for  TaskInfo task   listofTasks        System out format    s    d  n                task getTaskName    task getTimeMillis           OutPut   Total time in milliseconds for all tasks   999 Table describing all tasks performed   StopWatch     running time  millis    999 ----------------------------------------- ms           Task name ----------------------------------------- 00500  050   Method-1 00299  030   Method-2 00200  020   Method-3  Time taken by the last task    Method-3   200   Array of the data for tasks performed    Task Name  Time Taken  Method-1   500   Method-2   299   Method-3   200

User · Answer

I basically do variations of this  but considering how hotspot compilation works  if you want to get accurate results you need to throw out the first few measurements and make sure you are using the method in a real world  read application specific  application     If the JIT decides to compile it your numbers will vary heavily   so just be aware

User · Answer

If you want wall-clock time  long start time   System currentTimeMillis    object method    long end time   System currentTimeMillis    long execution time   end time - start time

User · Answer

I go with the simple answer  Works for me   long startTime   System currentTimeMillis     doReallyLongThing     long endTime   System currentTimeMillis     System out println  That took      endTime - startTime      milliseconds      It works quite well  The resolution is obviously only to the millisecond  you can do better with System nanoTime    There are some limitations to both  operating system schedule slices  etc   but this works pretty well   Average across a couple of runs  the more the better  and you ll get a decent idea

User · Answer

As  skaffman  said  use AOP OR you can use run time bytecode weaving  just like unit test method coverage tools use to transparently add timing info to methods invoked   You can look at code used by open source tools tools like Emma  http   downloads sourceforge net emma emma-2 0 5312-src zip modtime 1118607545 amp big mirror 0   The other opensource coverage tool is http   prdownloads sourceforge net cobertura cobertura-1 9-src zip download   If you eventually manage to do what you set out for  pls  share it back with the community here with your ant task jars

User · Answer

long startTime   System currentTimeMillis       code goes here long finishTime   System currentTimeMillis    long elapsedTime   finishTime - startTime     elapsed time in milliseconds

User · Answer

This probably isn t what you wanted me to say  but this is a good use of AOP  Whip an proxy interceptor around your method  and do the timing in there   The what  why and how of AOP is rather beyond the scope of this answer  sadly  but that s how I d likely do it    Edit  Here s a link to Spring AOP to get you started  if you re keen  This is the most accessible implementation of AOP that Iive come across for java   Also  given everyone else s very simple suggestions  I should add that AOP is for when you don t want stuff like timing to invade your code  But in many cases  that sort of simple and easy approach is fine

User · Answer

long startTime   System currentTimeMillis       code goes here long finishTime   System currentTimeMillis    long elapsedTime   finishTime - startTime     elapsed time in milliseconds

User · Answer

Also We can use StopWatch class of Apache commons for measuring the time   Sample code  org apache commons lang time StopWatch sw   new org apache commons lang time StopWatch     System out println  getEventFilterTreeData    Start Time       sw getTime     sw start        Method execution code  sw stop    System out println  getEventFilterTreeData    End Time       sw getTime

User · Answer

System currentTimeMillis    IS NOT a good approach for measuring the performance of your algorithms  It measures the total time you experience as a user watching the computer screen  It includes also time consumed by everything else running on your computer in the background  This could make a huge difference in case you have a lot of programs running on your workstation   Proper approach is  using java lang management package   From http   nadeausoftware com articles 2008 03 java tip how get cpu and user time benchmarking website  archive link      User time  is the time spent running your application s own code   System time  is the time spent running OS code on behalf of your application  such as for I O     getCpuTime   method gives you sum of those   import java lang management ManagementFactory  import java lang management ThreadMXBean   public class CPUUtils            Get CPU time in nanoseconds         public static long getCpuTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                  bean getCurrentThreadCpuTime      0L                 Get user time in nanoseconds         public static long getUserTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                  bean getCurrentThreadUserTime      0L                 Get system time in nanoseconds         public static long getSystemTime              ThreadMXBean bean   ManagementFactory getThreadMXBean             return bean isCurrentThreadCpuTimeSupported                   bean getCurrentThreadCpuTime    - bean getCurrentThreadUserTime       0L

User · Answer

There are a couple of ways to do that  I normally fall back to just using something like this    long start   System currentTimeMillis           do something     long end   System currentTimeMillis      or the same thing with System nanoTime     For something more on the benchmarking side of things there seems also to be this one  http   jetm void fm  Never tried it though

User · Answer

Just a small twist  if you don t use tooling and want to time methods with low execution time  execute it many times  each time doubling the number of times it is executed until you reach a second  or so  Thus  the time of the Call to System nanoTime and so forth  nor the accuracy of System nanoTime does affect the result much       int runs   0  runsPerRound   10      long begin   System nanoTime    end      do           for  int i 0  i lt runsPerRound    i  timedMethod            end   System nanoTime            runs    runsPerRound          runsPerRound    2        while  runs  lt  Integer MAX VALUE   2  amp  amp  1000000000L  gt  end - begin       System out println  Time for timedMethod   is              0 000000001    end-begin    runs     seconds      Of course  the caveats about using the wall clock apply  influences of JIT-compilation  multiple threads   processes etc  Thus  you need to first execute the method a lot of times first  such that the JIT compiler does its work  and then repeat this test multiple times and take the lowest execution time

User · Answer

long startTime   System currentTimeMillis       code goes here long finishTime   System currentTimeMillis    long elapsedTime   finishTime - startTime     elapsed time in milliseconds

User · Answer

There is always the old-fashioned way   long startTime   System nanoTime    methodToTime    long endTime   System nanoTime     long duration    endTime - startTime      divide by 1000000 to get milliseconds

User · Answer

JEP 230  Microbenchmark Suite  FYI  JEP 230  Microbenchmark Suite is an OpenJDK project to      Add a basic suite of microbenchmarks to the JDK source code  and make it easy for developers to run existing microbenchmarks and create new ones    This feature arrived in Java 12   Java Microbenchmark Harness  JMH   For earlier versions of Java  take a look at the Java Microbenchmark Harness  JMH  project on which JEP 230 is based

User · Answer

Really good code   http   www rgagnon com javadetails java-0585 html  import java util concurrent TimeUnit   long startTime   System currentTimeMillis                               long finishTime   System currentTimeMillis     String diff   millisToShortDHMS finishTime - startTime                converts time  in milliseconds  to human-readable format         lt dd  gt hh mm ss          public static String millisToShortDHMS long duration        String res           long days    TimeUnit MILLISECONDS toDays duration       long hours   TimeUnit MILLISECONDS toHours duration                     - TimeUnit DAYS toHours TimeUnit MILLISECONDS toDays duration        long minutes   TimeUnit MILLISECONDS toMinutes duration                       - TimeUnit HOURS toMinutes TimeUnit MILLISECONDS toHours duration        long seconds   TimeUnit MILLISECONDS toSeconds duration                     - TimeUnit MINUTES toSeconds TimeUnit MILLISECONDS toMinutes duration        if  days    0          res   String format   02d  02d  02d   hours  minutes  seconds             else         res   String format   dd 02d  02d  02d   days  hours  minutes  seconds             return res

User · Answer

There is always the old-fashioned way   long startTime   System nanoTime    methodToTime    long endTime   System nanoTime     long duration    endTime - startTime      divide by 1000000 to get milliseconds

User · Answer

Come on guys  Nobody mentioned the Guava way to do that  which is arguably awesome    import com google common base Stopwatch   Stopwatch timer   Stopwatch createStarted      method invocation LOG info  Method took      timer stop       The nice thing is that Stopwatch toString   does a good job of selecting time units for the measurement  I e  if the value is small  it ll output 38 ns  if it s long  it ll show 5m 3s  Even nicer   Stopwatch timer   Stopwatch createUnstarted    for            timer start       methodToTrackTimeFor       timer stop       methodNotToTrackTimeFor      LOG info  Method took      timer     Note  Google Guava requires Java 1 6

User · Answer

This probably isn t what you wanted me to say  but this is a good use of AOP  Whip an proxy interceptor around your method  and do the timing in there   The what  why and how of AOP is rather beyond the scope of this answer  sadly  but that s how I d likely do it    Edit  Here s a link to Spring AOP to get you started  if you re keen  This is the most accessible implementation of AOP that Iive come across for java   Also  given everyone else s very simple suggestions  I should add that AOP is for when you don t want stuff like timing to invade your code  But in many cases  that sort of simple and easy approach is fine

User · Answer

We are using AspectJ and Java annotations for this purpose  If we need to know to execution time for a method  we simple annotate it  A more advanced version could use an own log level that can enabled and disabled at runtime   public  interface Trace     boolean showParameters        Aspect public class TraceAspect              Around  tracePointcut    amp  amp   annotation trace   amp  amp   within TraceAspect      public Object traceAdvice   ProceedingJintPoint jP  Trace trace          Object result         initilize timer      try          result   jp procced          finally             calculate execution time             return result

User · Answer

Using AOP AspectJ and  Loggable annotation from jcabi-aspects you can do it easy and compact    Loggable Loggable DEBUG  public String getSomeResult          return some value     Every call to this method will be sent to SLF4J logging facility with DEBUG logging level  And every log message will include execution time

User · Answer

Here is pretty printed string ready formated seconds elapsed similar to google search time took to search           long startTime   System nanoTime                    methodToTime            long endTime   System nanoTime            long duration    endTime - startTime           long seconds    duration   1000    60             formatedSeconds    0 xy seconds          String formatedSeconds   String format   0  d seconds    seconds           System out println  formatedSeconds      formatedSeconds              i e actual formatedSeconds    0 52 seconds

User · Answer

You can use Metrics library which provides various measuring instruments  Add dependency    lt dependencies gt       lt dependency gt           lt groupId gt io dropwizard metrics lt  groupId gt           lt artifactId gt metrics-core lt  artifactId gt           lt version gt   metrics version  lt  version gt       lt  dependency gt   lt  dependencies gt    And configure it for your environment    Methods can be annotated with  Timed    Timed public void exampleMethod           some code     or piece of code wrapped with Timer   final Timer timer   metricsRegistry timer  some name    final Timer Context context   timer time       timed code context stop      Aggregated metrics can exported to console  JMX  CSV or other    Timed metrics output example   com example ExampleService exampleMethod              count   2          mean rate   3 11 calls minute      1-minute rate   0 96 calls minute      5-minute rate   0 20 calls minute     15-minute rate   0 07 calls minute                min   17 01 milliseconds                max   1006 68 milliseconds               mean   511 84 milliseconds             stddev   699 80 milliseconds             median   511 84 milliseconds               75   lt   1006 68 milliseconds               95   lt   1006 68 milliseconds               98   lt   1006 68 milliseconds               99   lt   1006 68 milliseconds             99 9   lt   1006 68 milliseconds

User · Answer

If you want wall-clock time  long start time   System currentTimeMillis    object method    long end time   System currentTimeMillis    long execution time   end time - start time

User · Answer

Using Instant and Duration from Java 8 s new API   Instant start   Instant now    Thread sleep 5000   Instant end   Instant now    System out println Duration between start  end      outputs   PT5S

User · Answer

Ok  this is a simple class to be used for simple simple timing of your functions  There is an example below it   public class Stopwatch       static long startTime      static long splitTime      static long endTime       public Stopwatch             start               public void start             startTime   System currentTimeMillis            splitTime   System currentTimeMillis            endTime   System currentTimeMillis               public void split             split                 public void split String tag            endTime   System currentTimeMillis            System out println  Split time for      tag            endTime - splitTime      ms            splitTime   endTime             public void end             end                public void end String tag            endTime   System currentTimeMillis            System out println  Final time for      tag            endTime - startTime      ms              Sample of use   public static Schedule getSchedule Activity activity context            String scheduleJson   null          Schedule schedule   null    - gt     Stopwatch stopwatch   new Stopwatch             InputStream scheduleJsonInputStream   activity context getResources   openRawResource R raw skating times     - gt     stopwatch split  open raw resource             scheduleJson   FileToString convertStreamToString scheduleJsonInputStream     - gt     stopwatch split  file to string             schedule   new Gson   fromJson scheduleJson  Schedule class     - gt     stopwatch split  parse Json      - gt     stopwatch end  Method getSchedule         return schedule      Sample of console output   Split time for  file to string   672 ms Split time for  parse Json   893 ms Final time for  get Schedule   1565 ms

User · Answer

As  skaffman  said  use AOP OR you can use run time bytecode weaving  just like unit test method coverage tools use to transparently add timing info to methods invoked   You can look at code used by open source tools tools like Emma  http   downloads sourceforge net emma emma-2 0 5312-src zip modtime 1118607545 amp big mirror 0   The other opensource coverage tool is http   prdownloads sourceforge net cobertura cobertura-1 9-src zip download   If you eventually manage to do what you set out for  pls  share it back with the community here with your ant task jars

User · Answer

Spring provides a utility class org springframework util StopWatch  as per JavaDoc      Simple stop watch  allowing for timing of a number of tasks  exposing   total running time and running time for each named task    Usage   StopWatch stopWatch   new StopWatch  Performance Test Result     stopWatch start  Method 1    doSomething1     method to test stopWatch stop     stopWatch start  Method 2    doSomething2     method to test stopWatch stop     System out println stopWatch prettyPrint       Output   StopWatch  Performance Test Result   running time  millis    12829 ----------------------------------------- ms           Task name ----------------------------------------- 11907  036   Method 1 00922  064   Method 2   With Aspects    Around  execution   my package             public Object logTime ProceedingJoinPoint joinPoint  throws Throwable       StopWatch stopWatch   new StopWatch        stopWatch start        Object retVal   joinPoint proceed        stopWatch stop        log info   execution time      stopWatch getTotalTimeMillis       ms        return retVal

User · Answer

I implemented a simple timer  And I think it s really useful   public class Timer      private static long start time       public static double tic            return start time   System nanoTime               public static double toc            return  System nanoTime  -start time  1000000000 0             That way you can time one or more actions   Timer tic       Code 1 System out println  Code 1 runtime    Timer toc     seconds        Code 2 System out println   Code 1   Code 2  runtime    Timer toc    seconds    Timer tic       Code 3 System out println  Code 3 runtime    Timer toc     seconds

User · Answer

It would be nice if java had a better functional support  so that the action  that needs to be measured  could be wrapped into a block    measure         your operation here     In java this could be done by anonymous functions  that look too verbose  public interface Timer       void wrap        public class Logger        public static void logTime Timer timer            long start   System currentTimeMillis            timer wrap            System out println       System currentTimeMillis   - start     ms               public static void main String a              Logger logTime new Timer                 public void wrap                        Your method here                 timeConsumingOperation                                          public static void timeConsumingOperation             for  int i   0  i lt  10000  i                 System out println  i    i

User · Answer

Ok  this is a simple class to be used for simple simple timing of your functions  There is an example below it   public class Stopwatch       static long startTime      static long splitTime      static long endTime       public Stopwatch             start               public void start             startTime   System currentTimeMillis            splitTime   System currentTimeMillis            endTime   System currentTimeMillis               public void split             split                 public void split String tag            endTime   System currentTimeMillis            System out println  Split time for      tag            endTime - splitTime      ms            splitTime   endTime             public void end             end                public void end String tag            endTime   System currentTimeMillis            System out println  Final time for      tag            endTime - startTime      ms              Sample of use   public static Schedule getSchedule Activity activity context            String scheduleJson   null          Schedule schedule   null    - gt     Stopwatch stopwatch   new Stopwatch             InputStream scheduleJsonInputStream   activity context getResources   openRawResource R raw skating times     - gt     stopwatch split  open raw resource             scheduleJson   FileToString convertStreamToString scheduleJsonInputStream     - gt     stopwatch split  file to string             schedule   new Gson   fromJson scheduleJson  Schedule class     - gt     stopwatch split  parse Json      - gt     stopwatch end  Method getSchedule         return schedule      Sample of console output   Split time for  file to string   672 ms Split time for  parse Json   893 ms Final time for  get Schedule   1565 ms

User · Answer

I have written a method to print the method execution time in a much readable form  For example  to calculate the factorial of 1 Million  it takes approximately 9 minutes  So the execution time get printed as   Execution Time  9 Minutes  36 Seconds  237 MicroSeconds  806193 NanoSeconds   The code is here   public class series       public static void main String   args                long startTime   System nanoTime             long n   10 00 000          printFactorial n            long endTime   System nanoTime            printExecutionTime startTime  endTime               public static void printExecutionTime long startTime  long endTime                long time ns   endTime - startTime          long time ms   TimeUnit NANOSECONDS toMillis time ns           long time sec   TimeUnit NANOSECONDS toSeconds time ns           long time min   TimeUnit NANOSECONDS toMinutes time ns           long time hour   TimeUnit NANOSECONDS toHours time ns            System out print   nExecution Time              if time hour  gt  0              System out print time hour     Hours              if time min  gt  0              System out print time min   60     Minutes              if time sec  gt  0              System out print time sec   60     Seconds              if time ms  gt  0              System out print time ms   1E 3     MicroSeconds              if time ns  gt  0              System out print time ns   1E 6     NanoSeconds

User · Answer

You can use Perf4j  Very cool utility  Usage is simple  String watchTag    target SomeMethod   StopWatch stopWatch   new LoggingStopWatch watchTag   Result result   null     Result is a type of a return value of a method try       result   target SomeMethod        stopWatch stop watchTag     success      catch  Exception e        stopWatch stop watchTag     fail    Exception was     e       throw e       More information can be found in Developer Guide  Edit  Project seems dead

User · Answer

Come on guys  Nobody mentioned the Guava way to do that  which is arguably awesome    import com google common base Stopwatch   Stopwatch timer   Stopwatch createStarted      method invocation LOG info  Method took      timer stop       The nice thing is that Stopwatch toString   does a good job of selecting time units for the measurement  I e  if the value is small  it ll output 38 ns  if it s long  it ll show 5m 3s  Even nicer   Stopwatch timer   Stopwatch createUnstarted    for            timer start       methodToTrackTimeFor       timer stop       methodNotToTrackTimeFor      LOG info  Method took      timer     Note  Google Guava requires Java 1 6

[java] How do I time a method's execution in Java?

Examples related to java

Examples related to timing

Examples related to execution-time