Wie wenn ich eine Ausführung der Methode in Java?
https://stackoverflow.com/questions/180158
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianFrage
Wie erhalte ich eine Ausführungszeit-Methode? Gibt es eine Timer-Utility-Klasse für Dinge wie Timing, wie lange eine Aufgabe übernimmt, etc?
Die meisten der Suchanfragen auf Google Rückkehr Ergebnisse für Zeiten, die Threads und Tasks planen, die nicht das, was ich will.
Lösung
Es gibt immer die altmodische Art und Weise:
long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();
long duration = (endTime - startTime); //divide by 1000000 to get milliseconds.
Andere Tipps
Ich gehe mit der einfachen Antwort. Funktioniert bei mir.
long startTime = System.currentTimeMillis();
doReallyLongThing();
long endTime = System.currentTimeMillis();
System.out.println("That took " + (endTime - startTime) + " milliseconds");
Es funktioniert ganz gut. Die Auflösung ist offensichtlich nur auf die Millisekunde, können Sie mit System.nanoTime (besser). Es gibt einige Einschränkungen sowohl (Betriebssystem Zeitplan Scheiben, usw.), aber das funktioniert ziemlich gut.
Durchschnitt über ein paar Durchläufe (je mehr, desto besser) und Sie erhalten eine anständige Vorstellung bekommen.
Come on guys! Niemand erwähnte den Guava Weg, dies zu tun (das ist wohl genial):
import com.google.common.base.Stopwatch;
Stopwatch timer = Stopwatch.createStarted();
//method invocation
LOG.info("Method took: " + timer.stop());
Das Schöne daran ist, dass Stopwatch.toString () macht einen guten Job Zeiteinheiten für die Messung auswählen. D. h wenn der Wert klein ist, wird es Ausgabe 38 ns, wenn es lang ist, wird es 5m 3s zeigen
Noch schöner:
Stopwatch timer = Stopwatch.createUnstarted();
for (...) {
timer.start();
methodToTrackTimeFor();
timer.stop();
methodNotToTrackTimeFor();
}
LOG.info("Method took: " + timer);
Hinweis: Google Guava erfordert Java 1.6 +
Verwenden Sie einen Profiler (JProfiler, Netbeans Profiler Visual VM, Eclipse-Profiler, etc). Hier finden Sie die genauesten Ergebnisse erhalten und ist die am wenigsten aufdringlich. Sie nutzen die eingebaute in JVM-Mechanismus für die Profilerstellung, die Sie auch zusätzliche Informationen wie Stack-Traces geben kann, Ausführungspfade und umfassendere Ergebnisse, wenn nötig.
Wenn ein voll integriertes Profiler, es faily trivial ist, ein Verfahren zu profilieren. Rechts klicken, Profiler -> In den Root-Methoden. Dann den Profiler laufen wie Sie einen Testlauf oder Debugger taten.
Geraffte alle Möglichkeiten zusammen an einem Ort.
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 ) );
Klar 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 Stoppuhr JAR «Ein Gegenstand der Stoppuhr ist in ns verstrichene Zeit Maßnahmen.
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 « Stoppuhr bietet eine komfortable API für 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 Datum Zeit API von Java 8 «A Dauer Objekt stellt eine Zeitspanne zwischen zwei Spring Framework bietet Stopwatch Utility-Klasse in Java verstrichene Zeit zu messen.
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());
}
Ausgabe:
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]
Dies ist wahrscheinlich nicht das, was Sie wollten, dass ich sage, aber das ist eine gute Verwendung von AOP. Peitsche einen Proxy-Abfangjäger um Ihre Methode, und tut das Timing drin.
Das, was, warum und wie von AOP ist eher über den Rahmen dieser Antwort, leider, aber das ist, wie ich wahrscheinlich würde es tun.
Edit: Hier ist ein Link Spring AOP zu beginnen Sie, wenn Sie daran interessiert sind. Dies ist die am besten zugängliche Implementierung von AOP, die Iíve für Java kommen über.
Auch, da alle anderen ist sehr einfach Anregungen, sollte ich hinzufügen, dass AOP für ist, wenn man solche Sachen Timing wollen nicht, Ihren Code zu erobern. Aber in vielen Fällen diese Art von einfach und leicht Ansatz ist in Ordnung.
System.currentTimeMillis(); ist kein guter Ansatz für die Leistung Ihrer Algorithmen messen. Es misst die gesamte Zeit, die Sie sich als Benutzer erleben Sie den Computer-Bildschirm beobachten. Es enthält auch alles andere auf Ihrem Rechner im Hintergrund verbraucht Zeit. Dies könnte einen großen Unterschied in Fall machen Sie viele Programme auf Ihrem Rechner ausgeführt wird.
Die richtige Ansatz wird mit java.lang.management Paket.
http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking Webseite:
- „User Zeit“ ist die Zeit, um Ihre Anwendung eigenen Code ausgegeben ausgeführt wird.
- „Systemzeit“ ist die Zeit OS Code im Namen Ihrer Anwendung (wie für die I / O) ausgegeben ausgeführt wird.
getCpuTime() Methode gibt Ihnen Summe die:
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;
}
}
Mit Java 8 Sie können auch mit jedem normalen Methoden: so etwas tun:
Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue
mit timeit wie:
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;
}
}
Mit dieser Methode können Sie einfach die Zeitmessung machen überall in Ihrem Code, ohne sie zu brechen. In diesem einfachen Beispiel drucke ich nur die Zeit. Können Sie einen Schalter für timeit, beispielsweise hinzufügen um die Uhrzeit nur in Debugmode oder etwas zu drucken.
Wenn Sie arbeiten mit Funktion Sie können ungefähr wie folgt tun:
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;
};
}
Auch können wir Stopwatch Klasse von Apache commons verwenden, um die Zeit zu messen.
Beispielcode
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());
Nur eine kleine Wendung, wenn Sie keine Werkzeuge verwenden und mit geringer Ausführungszeit zu Zeit Methoden wollen: führen Sie sie viele Male, jedes Mal die Anzahl der Verdoppelung es ausgeführt wird, bis eine Sekunde oder so erreichen. Somit ist die Zeit des Aufrufs zu System.nanoTime und so weiter, noch die Richtigkeit System.nanoTime viel das Ergebnis nicht beeinflusst.
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");
Natürlich sind die Einsprüche über die Wanduhr mit anwenden: Einflüsse von JIT-Kompilierung, mehrere Threads / Prozesse usw. So müssen Sie zuerst die Methode ausführen viel Mal zuerst, wie dass der JIT-Compiler tut seine Arbeit, und dann diesen Test mehrmals wiederholen und die niedrigste Ausführungszeit nehmen.
Wir sind mit AspectJ und Java-Annotationen für diesen Zweck. Wenn wir für ein Verfahren zur Ausführungszeit müssen wissen, wir einfachen annotate es. Eine erweiterte Version könnte eine eigene Protokollebene verwenden, und deaktiviert zur Laufzeit aktiviert werden.
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;
}
[...]
}
Wirklich guter 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;
}
JEP 230: Suite-Micro
FYI, JEP 230: Suite-Micro ist ein OpenJDK Projekt:
Fügen Sie eine grundlegende Suite von Microbenchmarks auf das JDK Quellcode und macht es für Entwickler einfach bestehende Microbenchmarks laufen und neue zu schaffen.
Mit dieser Funktion kam in Java 12 .
Java-Micro Harness (JMH)
Für frühere Versionen von Java, werfen Sie einen Blick auf die Java-Micro Harness (JMH) Projekt, an dem JEP 230 basiert.
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()));
}
}
Sie können mit Perf4j . Sehr cool Dienstprogramm. Die Verwendung ist einfach
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;
}
Weitere Informationen finden Sie im Developer Guide
Edit: Projekt scheint tot
ich im Grunde tun Variationen dieser, aber wenn man bedenkt, wie Hotspot Kompilierung funktioniert, wenn Sie Sie genaue Ergebnisse erhalten möchten, müssen Sie die ersten Messungen werfen, und stellen Sie sicher, dass Sie die Methode in einer realen Welt verwenden (lesen Sie anwendungsspezifische) Anwendung.
Wenn der JIT es Ihre Zahlen zu kompilieren entscheidet stark variieren. so nur bewusst sein,
Mit AOP / AspectJ und @Loggable Anmerkung von jcabi-Aspekte Sie tun können, es einfach und kompakt:
@Loggable(Loggable.DEBUG)
public String getSomeResult() {
// return some value
}
Jeder Aufruf dieser Methode wird mit DEBUG Protokollebene auf SLF4J Protokolleinrichtung gesendet werden. Und jeder Lognachricht Ausführungszeit enthalten.
Es gibt ein paar Möglichkeiten, das zu tun. Ich falle normalerweise wieder nur so etwas wie dies mit:
long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();
oder die gleiche Sache mit System.nanoTime ();
Für etwas mehr auf der Benchmarking-Seite der Dinge scheint auch dies zu sein: http: //jetm.void. fm / es nie versucht though.
Frühling bietet eine Utility-Klasse org .springframework.util.StopWatch , wie pro JavaDoc:
Einfache Stoppuhr, so dass für Timing einer Reihe von Aufgaben, Belichtungs- Gesamtlaufzeit und Laufzeit für jede benannte Aufgabe.
Verbrauch:
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());
Ausgabe:
StopWatch 'Performance Test Result': running time (millis) = 12829
-----------------------------------------
ms % Task name
-----------------------------------------
11907 036% Method 1
00922 064% Method 2
Mit Aspekten:
@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;
}
Ich habe eine Methode geschrieben, um die Verfahren der Ausführungszeit in einer viel lesbaren Form zu drucken. Zum Beispiel der Fakultät von 1 Million, dauert es ungefähr 9 Minuten zu berechnen. So erhält die Ausführungszeit gedruckt, wie:
Execution Time: 9 Minutes, 36 Seconds, 237 MicroSeconds, 806193 NanoSeconds
Der Code ist 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");
}
}
Wenn Sie möchten, Wandtaktzeit
long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;
Als „skaffman“ sagte Verwendung AOP ODER Sie Zeit Bytecode Weben laufen verwenden können, verwenden Sie einfach wie Unit-Test-Methode Coverage Tools transparent hinzuzufügen aufgerufen Timing-Informationen zu Methoden.
Sie auf Code aussehen kann durch Open-Source-Tools, Tools wie Emma ( http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0 ). Die andere Open-Source-Coverage Tool ist http://prdownloads.sourceforge.net/ cobertura / cobertura-1.9-src.zip? herunterladen .
Wenn Sie schließlich verwalten zu tun, was Sie sich vorgenommen für, pls. teilen Sie es mit der Gemeinschaft hier mit Ihren Ant-Task / Dosen zurück.
long startTime = System.currentTimeMillis();
// code goes here
long finishTime = System.currentTimeMillis();
long elapsedTime = finishTime - startTime; // elapsed time in milliseconds
Ich änderte den Code von der richtigen Antwort zu bekommen in Sekunden zur Folge haben:
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);
Sie können mit Metrics Bibliothek, die verschiedene Messgeräte zur Verfügung stellt. In Abhängigkeit:
<dependencies>
<dependency>
<groupId>io.dropwizard.metrics</groupId>
<artifactId>metrics-core</artifactId>
<version>${metrics.version}</version>
</dependency>
</dependencies>
Und es für Ihre Umgebung konfigurieren.
Methoden können mit @Timed kommentiert werden :
@Timed
public void exampleMethod(){
// some code
}
oder ein Stück Code eingewickelt mit Timer :
final Timer timer = metricsRegistry.timer("some_name");
final Timer.Context context = timer.time();
// timed code
context.stop();
Aggregiert Metriken können exportiert trösten, JMX, CSV oder andere.
@Timed Metriken Ausgabe Beispiel:
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
Sie können Stoppuhr Klasse von Federkernprojekt verwenden:
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
Dokumentation für Stoppuhr: Einfache Stoppuhr, so dass für Timing einer Reihe von Aufgaben, Gesamtlaufzeit ausgesetzt wird und für jede benannte Aufgabe Zeit. Verdeckt Verwendung von System.currentTimeMillis (), um die Lesbarkeit des Anwendungscodes zu verbessern und die Wahrscheinlichkeit von Berechnungsfehlern zu reduzieren. Beachten Sie, dass diese Aufgabe nicht als Thread-sicher ausgelegt und verwendet keine Synchronisation. Diese Klasse wird normalerweise verwendet, die Leistung zu überprüfen, während Proof-of-Konzepte und in der Entwicklung, und nicht als Teil der Produktionsanwendungen.
Sie können auf diese Weise versuchen, wenn nur die Zeit wollen wissen.
long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));
Ok, das ist eine einfache Klasse für einfaches einfaches Timing Ihrer Funktionen verwendet werden. Es ist ein Beispiel darunter.
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");
}
}
Beispiel für die Verwendung:
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;
}
Beispiel der Konsolenausgabe:
Split time for [file to string]: 672 ms
Split time for [parse Json]: 893 ms
Final time for [get Schedule]: 1565 ms
In Java 8 eine neue Klasse namens Instant eingeführt. Wie pro doc:
Instant stellt den Beginn einer Nanosekunde auf der Zeitlinie. Diese Klasse ist nützlich, um einen Zeitstempel zu erzeugen Maschinenzeit darzustellen. Die Reichweite eines Instant erfordert die Speicherung einer Nummer größer als ein lange. Um dies zu erreichen, speichert die Klasse eine lange darstellt, epoche Sekunden und ein int darstellt Nanosekunde-of-Sekunde, die immer zwischen 0 und 999.999.999. Die Epoche-Sekunden gemessen werden von der Standard-Java-Epoche des 1970-01-01T00: 00: 00Z wo Punkte nach der Epoche haben positive Werte und früheren Zeitpunkten haben negative Werte. Sowohl für die epoche zweiten und Nanosekunde Teile, ein größerer Wert ist immer später auf der Zeitlinie als ein kleinerer Wert.
Dies kann verwendet werden:
Instant start = Instant.now();
try {
Thread.sleep(7000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Instant end = Instant.now();
System.out.println(Duration.between(start, end));
Es druckt PT7.001S.
