Come posso eseguire il benchmark del tempo di esecuzione del metodo in java?

Question

Ho un programma che ho scritto io stesso in java, ma voglio testare i tempi di esecuzione del metodo e ottenere i tempi per i metodi specifici. Mi stavo chiedendo se è possibile, forse in qualche modo un plug-in di eclissi? o magari inserendo del codice?

Vedo, è un programma piuttosto piccolo, nient'altro che 1500 linee, che sarebbe meglio uno strumento dedicato o System.currentTimeMillis()?

Molte grazie

Answer 1

Altro che usare un profiler, un modo semplice per ottenere ciò che si vuole è la seguente:

public class SomeClass{ 
    public void somePublicMethod() 
    { 
     long startTime = System.currentTimeMillis(); 
     someMethodWhichYouWantToProfile(); 
     long endTime = System.currentTimeMillis(); 
     System.out.println("Total execution time: " + (endTime-startTime) + "ms"); 
    } 
} 

Answer 2

Si dovrebbe usare un profiler come

• jprofiler
• yourkit

saranno facilmente integrarsi con qualsiasi IDE e spettacolo qualunque dettaglio che vi serve.

Ovviamente questi strumenti sono complessi e pensati per essere utilizzati per profilare programmi complessi, se hai bisogno di alcuni semplici benchmark ti suggerisco di usare System.currentTimeMillis() o System.nanoTime() e calcolare il delta di millisecondi tra le chiamate da solo.

Answer 3

È possibile aggiungere questo codice e verrà indicato per quanto tempo il metodo è stato eseguito.

long millisecondsStart = System.currentTimeMillis(); 
executeMethod(); 
long timeSpentInMilliseconds = System.currentTimeMillis() - millisecondsStart; 

Answer 4

Utilizzando un profiler è meglio perché si può scoprire i tempi di esecuzione medi e dei colli di bottiglia nella vostra applicazione .

Io uso VisualVM. slick e semplice.

Answer 5

Jprofiler e yourkit sono buoni, ma costano.

Esiste un plug-in gratuito per eclispe chiamato TPTP (Test & Performance Tools Platform) che può fornire tempi di esecuzione del codice. Ecco un tutorial che ha portato a una rapida ricerca su google. http://www.eclipse.org/articles/Article-TPTP-Profiling-Tool/tptpProfilingArticle.html

Answer 6

Un'altra soluzione su misura potrebbe essere basato sul il seguente post: http://www.mkyong.com/spring/spring-aop-examples-advice/

Allora avete anche la possibilità di utilizzare le utilità in tutto il monitoraggio delle applicazioni & SNMP. Se hai bisogno di "misurare" i tuoi metodi su base regolare in un ambiente di produzione, dovresti considerare l'utilizzo di uno di quegli strumenti SNMP

Answer 7

Google Guava has a stopwatch, rende le cose semplici e facili.

Stopwatch stopwatch = Stopwatch.createStarted(); 
myFunctionCall(); 
LOGGER.debug("Time taken by myFunctionCall: " + stopwatch.stop()); 

Answer 8

Se il collo di bottiglia è abbastanza grande da essere osservato con un profiler, utilizzare un profilatore.

Se è necessaria una maggiore precisione, il modo migliore per misurare un pezzetto di codice è l'utilizzo di un framework di microbenchmark Java come OpenJDK's JMH o Google's Caliper. Credo che siano semplici da usare come JUnit e non solo otterrai risultati più accurati, ma acquisirai l'esperienza della community per farlo nel modo giusto.

Segue un microbenchmark JMH per misurare il tempo di esecuzione di Math.log():

private double x = Math.PI; 

@Benchmark 
public void myBenchmark() { 
    return Math.log(x) 
} 

Uso della currentMillis() e nanoTime() per misurazione ha molte limitazioni:

1. Hanno latenza (hanno anche il tempo di esecuzione) che influenzano le tue misurazioni.
2. Hanno MOLTO limitata precisione, questo significa che è possibile mesure cose da 26ns a 26ns in Linux e 300 o giù di lì in Windows ha descritto here
3. La fase di riscaldamento non viene preso in considerazione, rendendo le vostre misure fluttuano UN SACCO.

I currentMillis() e nanoTime() metodi in Java possono essere utili, ma devono essere utilizzate con ESTREMA CAUTELA oppure è possibile ottenere misure errate errori like this dove l'ordine dei frammenti misurati influenzare le misure o like this dove l'autore erroneamente concludere che diversi milioni di operazioni sono state eseguite in meno di un ms, quando in realtà il JMV non ha realizzato alcuna operazione e ha inserito il codice, senza alcun codice.

Ecco un video meraviglioso che spiega come microbenchmark la strada giusta: https://shipilev.net/#benchmarking

Answer 9

Per i test di misurazione del tempo rapido e sporco, non utilizzare il tempo a muro-clock (System.currentTimeMillis()). Preferisco System.nanoTime() invece:

public static void main(String... ignored) throws InterruptedException { 
    final long then = System.nanoTime(); 
    TimeUnit.SECONDS.sleep(1); 
    final long millis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - then); 
    System.out.println("Slept for (ms): " + millis); // = something around 1000. 
}