De meeste zoekopdrachten op Google Retourneerresultaten voor timers die schroefdraad en taken plannen, wat niet is wat ik wil.

1, Autoriteit 100%

Er is altijd de ouderwetse manier:

long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();
long duration = (endTime - startTime);  //divide by 1000000 to get milliseconds.

2, Autoriteit 17%

Ik ga met het eenvoudige antwoord. Werkt voor mij.

long startTime = System.currentTimeMillis();
doReallyLongThing();
long endTime = System.currentTimeMillis();
System.out.println("That took " + (endTime - startTime) + " milliseconds");

Het werkt vrij goed. De resolutie is natuurlijk alleen aan de milliseconde, je kunt het beter doen met systeem.nanotime (). Er zijn enkele beperkingen aan beide (besturingssysteemplanning, enz.) Maar dit werkt redelijk goed.

Gemiddeld over een paar runs (hoe meer hoe beter) en je krijgt een fatsoenlijk idee.

3, Autoriteit 14%

Kom op jongens! Niemand noemde de guava manier om dat te doen (wat betwistbaar geweldig is):

import com.google.common.base.Stopwatch;
Stopwatch timer = Stopwatch.createStarted();
//method invocation
LOG.info("Method took: " + timer.stop());

Het leuke is dat stopwatch.tostring () een goede taak doet om tijdeenheden te selecteren voor de meting. D.w.z. Als de waarde klein is, zal het 38 NS uitvoeren, als het lang is, laat het 5M 3S

zelfs mooier:

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

Opmerking: Google Guava vereist Java 1.6+

Antwoord 4, autoriteit 11%

Met behulp van Instanten Duurvan de nieuwe API van Java 8,

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

uitgangen,

PT5S

Antwoord 5, autoriteit 10%

Alle mogelijke manieren verzameld op één plek.

Datum

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

Systeem.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 leesable formaat

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: GoogleStopwatch^JAR« Een doel van Stopwatch is om de verstreken tijd in nanoseconden te meten.

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
« StopWatchbiedt een handige API voor 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 van Java 8« Een Duurobject vertegenwoordigt een periode tussen twee Directeobjecten.

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 Frameworkbiedt StopWatchhulpprogramma-klasse om de verstreken tijd in Java te meten.

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

Uitvoer:

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]

Antwoord 6, autoriteit 7%

Gebruik een profiler (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler, enz.). U krijgt de meest nauwkeurige resultaten en is het minst opdringerig. Ze gebruiken het ingebouwde JVM-mechanisme voor profilering, dat u ook extra informatie kan geven, zoals stacktraces, uitvoeringspaden en indien nodig uitgebreidere resultaten.

Als je een volledig geïntegreerde profiler gebruikt, is het niet eenvoudig om een methode te profileren. Klik met de rechtermuisknop, Profiler -> Toevoegen aan Root-methoden. Voer vervolgens de profiler uit zoals u een testrun of debugger deed.

7, Autoriteit 3%

Dit is waarschijnlijk niet wat je wilde dat ik zei, maar dit is een goed gebruik van AOP. Zweep een proxy-interceptor rond uw methode en doe de timing daar.

Wat, waarom en hoe van AOP is eerder de reikwijdte van dit antwoord, helaas, maar dat is hoe ik het waarschijnlijk zou doen.

EDIT: Hier is een link naar lente AOP Om je op weg te helpen, als je enthousiast bent. Dit is de meest toegankelijke implementatie van AOP die opkomt voor Java.

Ook, gezien de zeer eenvoudige suggesties van iedereen, zou ik moeten toevoegen dat AOP is voor wanneer je niet wilt dingen zoals timing om je code binnen te vallen. Maar in veel gevallen is dat soort eenvoudige en gemakkelijke aanpak prima.

8, Autoriteit 2%

Met Java 8 kun je ook iets dergelijks doen met elke normale methoden :

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

met timeit zoals:

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

Met deze methode kunt u overal in uw code gemakkelijk tijdmetingen uitvoeren zonder deze te breken. In dit eenvoudige voorbeeld print ik gewoon de tijd. Mag je een Switch toevoegen voor TimeIt, b.v. om alleen de tijd af te drukken in DebugMode of zoiets.

Als je met Functionwerkt, kun je zoiets als dit doen:

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

Antwoord 9, autoriteit 2%

We kunnen ook de StopWatch-klasse van Apache commons gebruiken om de tijd te meten.

Voorbeeldcode

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

Antwoord 10

JEP 230: Microbenchmark-suite

Ter info, JEP 230: Microbenchmark Suiteis een OpenJDKprojecteren naar:

Voeg een basispakket microbenchmarks toe aan de JDK-broncode en maak het ontwikkelaars gemakkelijk om bestaande microbenchmarks uit te voeren en nieuwe te maken.

Deze functie is beschikbaar in Java 12.

Java Microbenchmark-harnas (JMH)

Bekijk voor eerdere versies van Java de Java Microbenchmark Harness (JMH)project waarop JEP 230 is gebaseerd.

Antwoord 11

Een kleine wending, als je geen tooling gebruikt en methoden met een korte uitvoeringstijd wilt timen: voer het vele malen uit, elke keer verdubbelend het aantal keren dat het wordt uitgevoerd totdat je een seconde of zo bereikt. Dus de tijd van de oproep naar System.nanoTime enzovoort, noch de nauwkeurigheid van System.nanoTime hebben veel invloed op het resultaat.

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

Natuurlijk zijn de waarschuwingen over het gebruik van de wandklok van toepassing: invloeden van JIT-compilatie, meerdere threads / processen enz. U moet de methode dus eerst vaakeerst uitvoeren, zoals dat de JIT-compiler zijn werk doet, en herhaal deze test dan meerdere keren en neem de laagste uitvoeringstijd.

Antwoord 12

Hiervoor gebruiken we AspectJ- en Java-annotaties. Als we de uitvoeringstijd van een methode moeten weten, annoteren we deze eenvoudig. Een meer geavanceerde versie zou een eigen logniveau kunnen gebruiken dat tijdens runtime kan worden in- en uitgeschakeld.

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;
  }
  [...]
}

Antwoord 13

Echt goede 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
   *  "<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;
  }

Antwoord 14

Je kunt Perf4jgebruiken. Heel cool hulpprogramma. Gebruik is eenvoudig

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

Meer informatie is te vinden in de handleiding voor ontwikkelaars

Bewerken: Project lijkt dood

Antwoord 15

Spring biedt een hulpprogramma-klasse org .springframework.util.StopWatch, volgens JavaDoc:

Eenvoudige stopwatch, waardoor de timing van een aantal taken mogelijk is, het blootleggen
totale looptijd en looptijd voor elke genoemde taak.

Gebruik:

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

Uitvoer:

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

Met aspecten:

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

Antwoord 16

Ik heb een methode geschreven om de uitvoeringstijd van de methode in een goed leesbare vorm af te drukken.
Om bijvoorbeeld de faculteit van 1 miljoen te berekenen, duurt het ongeveer 9 minuten. Dus de uitvoeringstijd wordt afgedrukt als:

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

De code is hier:

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

17

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

18

Gebruik van AOP / ASPECTJ en @Loggableannotatie van JCABI-aspecten U kunt het eenvoudig en compact doen:

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

Elke aanroep van deze methode wordt verzonden naar de logfunctie van SLF4J met het logniveau DEBUG. En elk logbericht bevat de uitvoeringstijd.

Antwoord 19

Ik doe hier eigenlijk variaties op, maar als je bedenkt hoe hotspot-compilatie werkt, als je nauwkeurige resultaten wilt krijgen, moet je de eerste paar metingen weggooien en ervoor zorgen dat je de methode in een echte wereld gebruikt (lees toepassingsspecifiek) sollicitatie.

Als het JIT besluit het te compileren, zullen uw aantallen sterk variëren. dus let op

Antwoord 20

Er zijn een aantal manieren om dat te doen. Normaal gesproken val ik terug op het gebruik van zoiets als dit:

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

of hetzelfde met System.nanoTime();

Voor iets meer aan de benchmarkingkant lijkt er ook deze te zijn: http://jetm.void. fm/Heb het echter nooit geprobeerd.

Antwoord 21

Als je wandkloktijd wilt

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

Antwoord 22

U kunt de bibliotheek Metriekengebruiken die verschillende meetinstrumenten biedt. Afhankelijkheid toevoegen:

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

en configureer het voor uw omgeving.

Methoden kunnen worden geannoteerd met @Timed :

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

of stuk van de code gewikkeld met timer :

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

Geaggregeerde statistieken kunnen worden geëxporteerd naar de console, JMX, CSV of andere.

@TimedMetrics uitvoervoorbeeld:

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

23

Zoals “skaffan” zei, gebruik AOP of u kunt de looptijd Bytecode-weven gebruiken, net als eenheidstestmethode Dekkingstools gebruiken om transparant te voegen Timing-info toevoegen aan methoden die zijn aangeroepen.

U kunt kijken naar code die wordt gebruikt door open source tools-tools zoals Emma (http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0 ). De andere opensource-dekkingstool is http://prownloads.sourceforge.net/cobertura /cobertura-1.9-src.zip?download .

Als u uiteindelijk het lukt om te doen waarvoor u opzet, pls. Deel het hier terug met de gemeenschap met uw miertaak / potten.

24

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

25

Ik heb de code van het juiste antwoord gewijzigd om resultaat in seconden te krijgen:

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

26

OK, dit is een eenvoudige klasse die moet worden gebruikt voor eenvoudige eenvoudige timing van uw functies. Er is een voorbeeld hieronder.

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

Monster van gebruik:

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

Voorbeeld van console-uitgang:

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

27

U kunt stopwatch-klasse gebruiken van 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

Documentatie voor stopwatch:
Eenvoudige stopwatch, die de timing van een aantal taken mogelijk maakt, waarbij de totale looptijd en looptijd voor elke genoemde taak wordt weergegeven.
Verbergt het gebruik van System.currentTimeMillis(), verbetert de leesbaarheid van applicatiecode en vermindert de kans op rekenfouten.
Merk op dat dit object niet is ontworpen om thread-safe te zijn en geen synchronisatie gebruikt.
Deze klasse wordt normaal gesproken gebruikt om de prestaties te verifiëren tijdens proof-of-concepts en in ontwikkeling, in plaats van als onderdeel van productietoepassingen.

Antwoord 28

Je kunt het op deze manier proberen als je gewoon de tijd wilt weten.

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

Antwoord 29

In Java 8 wordt een nieuwe klasse met de naam Instantgeïntroduceerd. Volgens document:

Instant staat voor het begin van een nanoseconde op de tijdlijn. Dit
class is handig voor het genereren van een tijdstempel om de machinetijd weer te geven.
Het bereik van een moment vereist de opslag van een getal groter dan a
lang. Om dit te bereiken, slaat de klasse een lange representatie op
epoch-seconden en een int die nanoseconde-van-seconde vertegenwoordigt, wat zal
altijd tussen 0 en 999.999.999 liggen. De epoche-seconden worden gemeten
uit het standaard Java-tijdperk van 1970-01-01T00:00:00Z waar instants
na het tijdperk hebben positieve waarden, en eerdere momenten hebben
negatieve waarden. Voor zowel de epoch-seconde en nanoseconde delen, a
grotere waarde staat altijd later op de tijdlijn dan een kleinere waarde.

Dit kan worden gebruikt als:

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

Het drukt PT7.001Saf.