Wybieram prostą odpowiedź. Mi pasuje.

long startTime = System.currentTimeMillis();

doReallyLongThing();

long endTime = System.currentTimeMillis();

System.out.println("That took " + (endTime - startTime) + " milliseconds");

Średnia w kilku biegach (im więcej tym lepiej) i dostaniesz przyzwoity pomysł.

Dalej chłopaki! Nikt nie wspomniał o Guava sposób na to (co jest prawdopodobnie niesamowite):

import com.google.common.base.Stopwatch;

Stopwatch timer = Stopwatch.createStarted();
//method invocation
LOG.info("Method took: " + timer.stop());

Jeszcze ładniej:

Stopwatch timer = Stopwatch.createUnstarted();
for (...) {
   timer.start();
   methodToTrackTimeFor();
   timer.stop();
   methodNotToTrackTimeFor();
}
LOG.info("Method took: " + timer);

Uwaga: Google Guava wymaga Javy 1.6+

UżycieInstant iDuration z nowego API Java 8,

Instant start = Instant.now();
Thread.sleep(5000);
Instant end = Instant.now();
System.out.println(Duration.between(start, end));

Wyjścia,

PT5S

zebrał wszystkie możliwe sposoby w jedno miejsce.

Data

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 ) );

Czytelny Dla Człowieka 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;
}

Guawa: Google Stoper^JAR " celem stopera jest mierzenie upływającego czasu w nanosekundach.

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 Lang^JAR " Stoper zapewnia wygodne API dla timingów.

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 - CZAS

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 z Java 8 " A Duration obiekt reprezentuje okres czasu pomiędzy dwoma obiektamiInstant .

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 zapewnia klasę narzędzia StopWatch do pomiaru czasu w Javie.

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());
}

Wyjście:

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]

Użyj profilera (Jprofiler, Netbeans Profiler, Visual vm, Eclipse Profiler, itp.). Otrzymasz najbardziej dokładne wyniki i jest najmniej natrętny. Używają wbudowanego mechanizmu JVM do profilowania, który może również dostarczyć dodatkowych informacji, takich jak ślady stosu, ścieżki realizacji i bardziej wyczerpujące wyniki, jeśli to konieczne.

Podczas korzystania z w pełni zintegrowanego profilera, nie jest trywialne profilowanie metody. Kliknij prawym przyciskiem myszy, Profiler - > Dodaj do metod Root. Następnie uruchom profiler tak jak ty wykonujemy test lub debugger.

System.currentTimeMillis(); nie jest dobrym podejściem do pomiaru wydajności algorytmów. Mierzy całkowity czas, którego doświadczasz jako użytkownik oglądający ekran komputera. Obejmuje to również czas zużywany przez Wszystko inne uruchomione na komputerze w tle. Może to mieć ogromne znaczenie w przypadku, gdy na stacji roboczej działa wiele programów.

Właściwe podejście polega na użyciu java.lang.management pakietu.

Od http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking website (archive link):

• "Czas użytkownika" to czas spędzony na uruchamianiu własnego kodu aplikacji.
• "czas systemowy" to czas spędzony na uruchamianiu kodu systemu operacyjnego w imieniu aplikacji (np. dla I/O).

getCpuTime() metoda daje sumę tych:

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;
    }

}

To prawdopodobnie nie jest to, co chciałeś mi powiedzieć, ale to jest dobre wykorzystanie AOP. Rozłóż proxy interceptor wokół swojej metody, i zrób tam czas.

Co, dlaczego i jak AOP jest raczej poza zakresem tej odpowiedzi, niestety, ale tak bym to zrobił.

Edit: Oto link do Spring AOP na początek, jeśli jesteś chętny. Jest to najbardziej dostępna implementacja AOP, z jaką spotkałem się w Javie.

Również, biorąc pod uwagę każdy inny bardzo proste sugestie, powinienem dodać, że AOP jest dla, gdy nie chcesz rzeczy takich jak czas do inwazji kodu. Ale w wielu przypadkach takie proste i łatwe podejście jest w porządku.

Z Javą 8 możesz zrobić coś takiego z każdą normalną metodą :

Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue

Z czasem jak:

public class TimeIt {

public static <T> T printTime(Callable<T> 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;
}
}

Dzięki tej metodzie możesz łatwo dokonać pomiaru czasu w dowolnym miejscu kodu bez jego łamania. W tym prostym przykładzie po prostu drukuję czas. Możesz dodać przełącznik dla TimeIt, np. aby wydrukować tylko czas w DebugMode lub coś takiego.

Jeśli pracujesz z Funkcja możesz zrobić coś takiego:

Function<Integer, Integer> yourFunction= (n) -> {
        return IntStream.range(0, n).reduce(0, (a, b) -> a + b);
    };

Integer returnValue = TimeIt.printTime2(yourFunction).apply(10000);
//do stuff with your returnValue

public static <T, R> Function<T, R> printTime2(Function<T, R> task) {
    return (t) -> {
        long startTime = System.currentTimeMillis();
        R apply = task.apply(t);
        System.out.print((System.currentTimeMillis() - startTime) / 1000d
                + "s");
        return apply;
    };
}

Możemy również użyć klasy StopWatch Apache commons do pomiaru czasu.

Przykładowy kod

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());

JEP 230: Microbenchmark Suite

FYI, JEP 230: Pakiet Microbenchmark jest projektem OpenJDK do:

Dodaj podstawowy pakiet mikrobenchmarks do kodu źródłowego JDK i ułatw programistom uruchamianie istniejących mikrobenchmarks i tworzenie nowych.

Ta funkcja pojawiła się w Java 12 .

Java Microbenchmark (JMH)

Dla wcześniejszych wersji Javy, spójrz na uprząż Java Microbenchmark (JMH) projekt, na którym opiera się JEP 230.

Tylko mała zmiana, jeśli nie używasz narzędzi i chcesz mierzyć metody z niskim czasem wykonania: wykonaj je wiele razy, za każdym razem podwajając liczbę razy, aż osiągniesz sekundę lub więcej. Tak więc, czas wezwania do systemu.nanoTime i tak dalej, ani dokładność systemu.nanoTime ma duży wpływ na wynik.

    int runs = 0, runsPerRound = 10;
    long begin = System.nanoTime(), end;
    do {
        for (int i=0; i<runsPerRound; ++i) timedMethod();
        end = System.nanoTime();
        runs += runsPerRound;
        runsPerRound *= 2;
    } while (runs < Integer.MAX_VALUE / 2 && 1000000000L > end - begin);
    System.out.println("Time for timedMethod() is " + 
        0.000000001 * (end-begin) / runs + " seconds");

Oczywiście obowiązują zastrzeżenia dotyczące korzystania z zegara ściennego: wpływy JIT-compilation, wiele wątków / procesów itp. Dlatego musisz najpierw wykonaj metodę dużo razy, tak aby kompilator JIT wykonał swoją pracę, a następnie powtórz ten test wiele razy i weź najniższy czas wykonania.

Używamy do tego celu adnotacji AspectJ i Java. Jeśli musimy znać czas wykonania danej metody, po prostu ją adnotujemy. Bardziej zaawansowana wersja może używać własnego poziomu dziennika, który może być włączony i wyłączony w czasie wykonywania.

public @interface Trace {
  boolean showParameters();
}

@Aspect
public class TraceAspect {
  [...]
  @Around("tracePointcut() && @annotation(trace) && !within(TraceAspect)")
  public Object traceAdvice ( ProceedingJintPoint jP, Trace trace ) {

    Object result;
    // initilize timer

    try { 
      result = jp.procced();
    } finally { 
      // calculate execution time 
    }

    return result;
  }
  [...]
}

Naprawdę dobry kod.

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
   *  "<dd:>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;
  }

Możesz użyć Perf4j . Bardzo fajne narzędzie. Użycie jest proste

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; 
}

Więcej informacji można znaleźć w Developer Guide

Edit: Project seems dead

Spring zapewnia klasę użytkową org.springframework.util.Stoper , wg JavaDoc:

Prosty stoper, pozwalający na wykonanie wielu zadań, odsłaniający całkowity czas pracy i czas pracy dla każdego nazwanego zadania.

Użycie:

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());

Wyjście:

StopWatch 'Performance Test Result': running time (millis) = 12829
-----------------------------------------
ms     %     Task name
-----------------------------------------
11907  036%  Method 1
00922  064%  Method 2

Z Aspektami:

@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;
}

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()));
    }

}

Za pomocą AOP / AspectJ i @Loggable adnotacja z jcabi-aspekty możesz to zrobić łatwo i kompaktowo:

@Loggable(Loggable.DEBUG)
public String getSomeResult() {
  // return some value
}

Każde wywołanie tej metody zostanie wysłane do obiektu logowania SLF4J z poziomem logowania DEBUG. A każda wiadomość dziennika będzie zawierać czas wykonania.

Napisałem metodę do drukowania czasu wykonania metody w znacznie czytelnej formie. Na przykład, aby obliczyć czynnik 1 miliona, trwa około 9 minut. Tak więc czas wykonania zostanie wydrukowany jako:

Execution Time: 9 Minutes, 36 Seconds, 237 MicroSeconds, 806193 NanoSeconds

Kod jest tutaj:

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 > 0)
            System.out.print(time_hour + " Hours, ");
        if(time_min > 0)
            System.out.print(time_min % 60 + " Minutes, ");
        if(time_sec > 0)
            System.out.print(time_sec % 60 + " Seconds, ");
        if(time_ms > 0)
            System.out.print(time_ms % 1E+3 + " MicroSeconds, ");
        if(time_ns > 0)
            System.out.print(time_ns % 1E+6 + " NanoSeconds");
    }
}

W zasadzie robię tego wariacje, ale biorąc pod uwagę, jak działa kompilacja hotspot, jeśli chcesz uzyskać dokładne wyniki, musisz wyrzucić kilka pierwszych pomiarów i upewnić się, że używasz tej metody w prawdziwym świecie (przeczytaj specyficzną aplikację).

Jeśli JIT zdecyduje się go skompilować, twoje liczby będą się znacznie różnić. więc po prostu bądź świadomy

Jest na to kilka sposobów. Normalnie wracam do używania czegoś takiego:

long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();

Lub to samo z systemem.nanoTime ();

Dla czegoś więcej na stronie benchmarkingu rzeczy wydaje się być również ten: http://jetm.void.fm nigdy nie próbowałem.

Jeśli chcesz Zegar Ścienny

long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;

Możesz użyć biblioteki Metrics , która zapewnia różne przyrządy pomiarowe. Add dependency:

<dependencies>
    <dependency>
        <groupId>io.dropwizard.metrics</groupId>
        <artifactId>metrics-core</artifactId>
        <version>${metrics.version}</version>
    </dependency>
</dependencies>

I skonfigurować go dla swojego środowiska.

Metody mogą być przypisane za pomocą @ Timed :

@Timed
public void exampleMethod(){
    // some code
}

Lub kawałek kodu owinięty Timer :

final Timer timer = metricsRegistry.timer("some_name");
final Timer.Context context = timer.time();
// timed code
context.stop();

Zagregowane metryki mogą być eksportowane do konsoli, JMX, CSV lub innych.

@Timed przykład wyjściowy metryki:

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% <= 1006.68 milliseconds
              95% <= 1006.68 milliseconds
              98% <= 1006.68 milliseconds
              99% <= 1006.68 milliseconds
            99.9% <= 1006.68 milliseconds

Jak powiedział "skaffman", użyj AOP lub możesz użyć run time bytecode weaving, podobnie jak narzędzia do testowania jednostkowego używają do przezroczystego dodawania informacji o czasie do wywoływanych metod.

Możesz spojrzeć na kod używany przez narzędzia open source narzędzia takie jak Emma (http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0). innym narzędziem opensource coverage jest http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download .

Jeśli w końcu uda Ci się zrobić to, na co się zdecydowałeś, pls. podziel się nim ze społecznością tutaj ze swoimi zadaniami/słoikami mrówek.

long startTime = System.currentTimeMillis();
// code goes here
long finishTime = System.currentTimeMillis();
long elapsedTime = finishTime - startTime; // elapsed time in milliseconds

Zmodyfikowałem kod z poprawnej odpowiedzi, aby uzyskać wynik w sekundach:

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);

Możesz użyć klasy stopera z projektu spring core:

Kod:

StopWatch stopWatch = new StopWatch()
stopWatch.start();  //start stopwatch
// write your function or line of code.
stopWatch.stop();  //stop stopwatch
stopWatch.getTotalTimeMillis() ; ///get total time

Dokumentacja dla stopera: Prosty stoper, pozwalający na synchronizację wielu zadań, pokazujący całkowity czas pracy i czas pracy dla każdego nazwanego zadania. Ukrywa korzystanie z systemu.currentTimeMillis (), poprawiając czytelność kodu aplikacji i zmniejszając prawdopodobieństwo błędów obliczeniowych. Zauważ, że ten obiekt nie jest zaprojektowany tak, aby był bezpieczny dla wątków i nie używa synchronizacji. To klasa jest zwykle używana do weryfikacji wydajności podczas proof-of-concepts i w rozwoju, a nie jako część aplikacji produkcyjnych.

Możesz spróbować w ten sposób, jeśli chcesz znać czas.

long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));    

Ok, jest to prosta klasa, która może być używana do prostego synchronizowania funkcji. Poniżej znajduje się przykład.

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");
    }
}

Próbka użycia:

public static Schedule getSchedule(Activity activity_context) {
        String scheduleJson = null;
        Schedule schedule = null;
/*->*/  Stopwatch stopwatch = new Stopwatch();

        InputStream scheduleJsonInputStream = activity_context.getResources().openRawResource(R.raw.skating_times);
/*->*/  stopwatch.split("open raw resource");

        scheduleJson = FileToString.convertStreamToString(scheduleJsonInputStream);
/*->*/  stopwatch.split("file to string");

        schedule = new Gson().fromJson(scheduleJson, Schedule.class);
/*->*/  stopwatch.split("parse Json");
/*->*/  stopwatch.end("Method getSchedule"); 
    return schedule;
}

Przykładowe wyjście konsoli:

Split time for [file to string]: 672 ms
Split time for [parse Json]: 893 ms
Final time for [get Schedule]: 1565 ms

W Javie 8 wprowadzono nową klasę o nazwie Instant. Zgodnie z doc:

Instant reprezentuje początek nanosekundy na linii czasu. To klasa jest przydatna do generowania znacznika czasu reprezentującego czas maszyny. Zakres chwili wymaga przechowywania liczby większej niż długa. Aby to osiągnąć, Klasa przechowuje długą reprezentującą epoch-sekund i int reprezentujący nanosekundę sekundy, która będzie zawsze będzie między 0 a 999,999,999. Epoka-sekundy są mierzone ze standardowej epoki Javy z 1970-01-01T00: 00: 00Z gdzie instancje po epoce mają wartości dodatnie, a wcześniejsze momenty mają wartości ujemne. Zarówno dla części epoki, jak i nanosekund, a większa wartość jest zawsze później na linii czasu niż mniejsza wartość.

To może być użyte jako:

Instant start = Instant.now();
try {
    Thread.sleep(7000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
Instant end = Instant.now();
System.out.println(Duration.between(start, end));

Drukuje PT7.001S.