streamalism.org

1. Oversikt

I denne artikkelen skal vi se på hvordan vi måler forløpt tid i Java. Selv om dette kan høres enkelt ut, er det noen få fallgruver som vi må være klar over.

Vi vil utforske standard Java-klasser og eksterne pakker som gir funksjonalitet for å måle forløpt tid.

2. Enkle målinger

2.1. currentTimeMillis ()

Når vi møter et krav om å måle forløpt tid i Java, kan vi prøve å gjøre det som:

lang start = System.currentTimeMillis (); // ... lang finish = System.currentTimeMillis (); long timeElapsed = mål - start;

Hvis vi ser på koden, er det veldig fornuftig. Vi får et tidsstempel i starten, og vi får et nytt tidsstempel når koden er ferdig. Forløpt tid er forskjellen mellom disse to verdiene.

Derimot, resultatet kan og vil være unøyaktig som System.currentTimeMillis () målinger veggur tid. Veggklokketid kan endre seg av mange grunner, f.eks. endring av systemtiden kan påvirke resultatene, ellers vil et sprang sekund forstyrre resultatet.

2.2. nanoTime ()

En annen metode i java.lang.System klasse er nanoTime (). Hvis vi ser på Java-dokumentasjonen, finner vi følgende uttalelse:

“Denne metoden kan bare brukes til å måle forløpt tid og er ikke relatert til noen annen forestilling om system eller veggklokketid.”

La oss bruke det:

lang start = System.nanoTime (); // ... lang finish = System.nanoTime (); long timeElapsed = mål - start;

Koden er i utgangspunktet den samme som før. Den eneste forskjellen er metoden som brukes for å få tidsstempler - nanoTime () i stedet for currentTimeMillis ().

La oss også merke det nanoTime ()returnerer tydeligvis tid i nanosekunder. Derfor, hvis den forløpte tiden måles i en annen tidsenhet, må vi konvertere den deretter.

For eksempel, for å konvertere til millisekunder må vi dele resultatet i nanosekunder med 1.000.000.

Nok en fallgruve med nanoTime () er det selv om det gir nanosekund presisjon, garanterer det ikke nanosekund oppløsning (dvs. hvor ofte verdien oppdateres).

Imidlertid garanterer det at oppløsningen blir minst like god som den currentTimeMillis ().

3. Java 8

Hvis vi bruker Java 8 - kan vi prøve det nye java.tid. øyeblikkelig og java.time. varighet klasser. Begge er uforanderlige, trådsikre og bruker sin egen tidsskala, the Java tidsskala, som alle klasser innen det nye java.time API.

3.1. Java tidsskala

Den tradisjonelle måten å måle tid på er å dele en dag i 24 timer på 60 minutter på 60 sekunder, noe som gir 86.400 sekunder om dagen. Imidlertid er soldagene ikke alltid like lange.

UTC-tidsskala lar faktisk en dag ha 86.399 eller 86.401 SI sekunder. Et SI-sekund er et vitenskapelig “Standard International second” og er definert av perioder med stråling av cesium 133-atomet). Dette er nødvendig for å holde dagen på linje med solen.

Java Time-Scale deler hver kalenderdag i nøyaktig 86.400 underavdelinger, kjent som sekunder. Det er ingen sprangsekunder.

3.2. Umiddelbar Klasse

De Umiddelbar klasse representerer et øyeblikk på tidslinjen. I utgangspunktet er det et numerisk tidsstempel siden standard Java-epoken til 1970-01-01T00: 00: 00Z.

For å få gjeldende tidsstempel kan vi bruke Øyeblikkelig. Nå () statisk metode. Denne metoden gjør det mulig å sende inn et valgfritt Klokke parameter. Hvis den utelates, bruker den systemklokken i standard tidssone.

Vi kan lagre start- og sluttider i to variabler, som i tidligere eksempler. Deretter kan vi beregne tiden som har gått mellom begge øyeblikkene.

Vi kan i tillegg bruke Varighet klasse og det er mellom() metode for å oppnå varigheten mellom to Umiddelbar gjenstander. Til slutt må vi konvertere Varighet til millisekunder:

Øyeblikkelig start = Øyeblikkelig. Nå (); // KODE HER Øyeblikkelig finish = Instant.now (); long timeElapsed = Duration.between (start, finish) .toMillis ();

4. Stoppeklokke

Apache Commons Lang går videre til biblioteker Stoppeklokke klasse som kan brukes til å måle forløpt tid.

4.1. Maven avhengighet

Vi kan få den siste versjonen ved å oppdatere pom.xml:

 org.apache.commons commons-lang3 3.7 

Den siste versjonen av avhengigheten kan sjekkes her.

4.2. Måling av forløpt tid med Stoppeklokke

Først og fremst må vi få en forekomst av klassen, og så kan vi bare måle den forløpne tiden:

StopWatch = ny StopWatch (); watch.start ();

Når vi har en klokke i gang, kan vi utføre koden vi ønsker å måle, og på slutten kaller vi bare Stoppe() metode. Til slutt, for å få det faktiske resultatet, ringer vi getTime ():

watch.stop (); System.out.println ("Forløpt tid:" + watch.getTime ()); // Trykk: Forløpt tid: 2501

Stoppeklokke har noen få andre hjelpemetoder som vi kan bruke for å stoppe eller gjenoppta måling. Dette kan være nyttig hvis vi trenger å gjøre vår referanse mer komplisert.

Til slutt, la oss merke at klassen ikke er trådsikker.

5. Konklusjon

Det er mange måter å måle tid på Java. Vi har dekket en veldig “tradisjonell” (og unøyaktig) måte ved å bruke currentTimeMillis (). I tillegg sjekket vi Apache Common Stoppeklokke og så på de nye klassene som er tilgjengelige i Java 8.

Samlet sett, for enkle og korrekte målinger av den forløpne tiden nanoTime () metoden er tilstrekkelig. Det er også kortere å skrive enn currentTimeMillis ().

La oss imidlertid merke oss at for riktig benchmarking, i stedet for å måle tid manuelt, kan vi bruke et rammeverk som Java Microbenchmark Harness (JMH). Dette emnet går utenfor omfanget av denne artikkelen, men vi utforsket det her.

Til slutt, som alltid, finner du koden som ble brukt under diskusjonen på GitHub.