sentencia - retornar un string en java
¿Cómo cronometro la ejecución de un método en Java? (30)
¿Cómo obtengo el tiempo de ejecución de un método? ¿Existe una clase de utilidad del temporizador para cosas como la sincronización del tiempo que tarda una tarea, etc.?
La mayoría de las búsquedas en Google devuelven resultados para temporizadores que programan subprocesos y tareas, que no es lo que quiero.
JEP 230: Microbenchmark Suite
FYI, JEP 230: Microbenchmark Suite es una propuesta de OpenJDK para:
Agregue un conjunto básico de microbenchmarks al código fuente de JDK, y facilite a los desarrolladores la ejecución de microbenchmarks existentes y la creación de nuevos.
Esta propuesta no hizo el corte para Java 9, pero puede agregarse más adelante.
Arnés de Java Microbenchmark (JMH)
Mientras tanto, es posible que desee ver el proyecto de Java Microbenchmark Harness (JMH) en el que se basa la propuesta.
¡Vamos chicos! Nadie mencionó la forma en que lo hizo la Guava (lo que es sin duda impresionante):
import com.google.common.base.Stopwatch;
Stopwatch timer = Stopwatch.createStarted();
//method invocation
LOG.info("Method took: " + timer.stop());
Lo bueno es que Stopwatch.toString () hace un buen trabajo al seleccionar las unidades de tiempo para la medición. Es decir, si el valor es pequeño, generará 38 ns, si es largo, mostrará 5m 3s
Aún mejor:
Stopwatch timer = Stopwatch.createUnstarted();
for (...) {
timer.start();
methodToTrackTimeFor();
timer.stop();
methodNotToTrackTimeFor();
}
LOG.info("Method took: " + timer);
Nota: Google Guava requiere Java 1.6+
Básicamente hago variaciones de esto, pero teniendo en cuenta cómo funciona la compilación de hotspot, si desea obtener resultados precisos, debe descartar las primeras mediciones y asegurarse de que está utilizando el método en una aplicación del mundo real (lea la aplicación específica).
Si el JIT decide compilarlo, sus números variarán considerablemente. así que ten cuidado
Como dijo "skaffman", use AOP O puede usar el tejido de bytecode de tiempo de ejecución, al igual que las herramientas de cobertura del método de prueba unitaria se utilizan para agregar de forma transparente la información de tiempo a los métodos invocados.
Puede ver el código utilizado por herramientas de código abierto como Emma ( http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0 ). La otra herramienta de cobertura de código abierto es http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download .
Si finalmente logras hacer lo que te propusiste, por favor. Compártelo de nuevo con la comunidad aquí con tus tareas / tarros de hormigas.
Con Java 8 también puedes hacer algo como esto con todos los métodos normales:
Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue
con TimeIt gusta:
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;
}
}
Con este método, puede realizar mediciones de tiempo fáciles en cualquier parte de su código sin romperlo. En este ejemplo simple acabo de imprimir el tiempo. Puede agregar un Switch para TimeIt, por ejemplo, para imprimir solo la hora en DebugMode o algo así.
Si está trabajando con Function , puede hacer algo como esto:
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;
};
}
En Java 8 se introduce una nueva clase llamada Instant . Según el documento:
Instant representa el inicio de un nanosegundo en la línea de tiempo. Esta clase es útil para generar una marca de tiempo para representar el tiempo de la máquina. El rango de un instante requiere el almacenamiento de un número mayor que un largo. Para lograr esto, la clase almacena una larga representación de épocas y una int que representa nanosegundos de segundo, que siempre estará entre 0 y 999.999.999. Las épocas-segundos se miden a partir de la época estándar de Java de 1970-01-01T00: 00: 00Z, donde los instantes posteriores a la época tienen valores positivos y los instantes anteriores tienen valores negativos. Tanto para las partes de epoch-second como para los nanosegundos, un valor mayor siempre se encuentra más adelante en la línea de tiempo que un valor menor.
Esto puede ser usado como:
Instant start = Instant.now();
try {
Thread.sleep(7000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Instant end = Instant.now();
System.out.println(Duration.between(start, end));
Imprime PT7.001S .
Estamos utilizando las anotaciones de AspectJ y Java para este propósito. Si necesitamos saber el tiempo de ejecución de un método, simplemente lo anotamos. Una versión más avanzada podría usar un nivel de registro propio que puede habilitarse y deshabilitarse en tiempo de ejecución.
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;
}
[...]
}
Hay un par de maneras de hacer eso. Normalmente me limito a usar algo como esto:
long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();
o lo mismo con System.nanoTime ();
Para algo más en el punto de referencia de las cosas también parece haber éste: http://jetm.void.fm/ Nunca lo intenté sin embargo.
Mediciones de rendimiento en mi máquina.
- System.nanoTime (): 750ns
- System.currentTimeMillis (): 18ns
Como se mencionó, se piensa que System.nanoTime () mide el tiempo transcurrido. Solo tenga en cuenta el costo si se usa dentro de un bucle o similar.
Modifiqué el código de la respuesta correcta para obtener el resultado en segundos:
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);
Muy buen código.
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;
}
Ok, esta es una clase simple para ser usada para una simple sincronización simple de sus funciones. Hay un ejemplo debajo.
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");
}
}
Muestra de uso:
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;
}
Ejemplo de salida de consola:
Split time for [file to string]: 672 ms
Split time for [parse Json]: 893 ms
Final time for [get Schedule]: 1565 ms
Probablemente esto no sea lo que quería que dijera, pero es un buen uso de AOP. Gire un interceptor proxy alrededor de su método y haga el tiempo allí.
El qué, por qué y cómo de AOP está más allá del alcance de esta respuesta, lamentablemente, pero así es como lo haría.
Edit: Aquí hay un enlace a Spring AOP para que comiences, si estás interesado. Esta es la implementación más accesible de AOP que he encontrado para Java.
Además, dadas las sugerencias muy simples de todos los demás, debo agregar que AOP es para cuando no quieres que el tiempo invada a tu código. Pero en muchos casos, ese tipo de enfoque simple y fácil está bien.
Puede utilizar la biblioteca de Metrics que proporciona varios instrumentos de medición. Añadir dependencia:
<dependencies>
<dependency>
<groupId>io.dropwizard.metrics</groupId>
<artifactId>metrics-core</artifactId>
<version>${metrics.version}</version>
</dependency>
</dependencies>
Y configúralo para tu entorno.
Los métodos pueden ser anotados con @Timed :
@Timed
public void exampleMethod(){
// some code
}
o pieza de código envuelto con Timer :
final Timer timer = metricsRegistry.timer("some_name");
final Timer.Context context = timer.time();
// timed code
context.stop();
Las métricas agregadas se pueden exportar a la consola, JMX, CSV u otros.
@Timed salida de métricas @Timed :
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
Puedes intentarlo de esta manera si solo quieres saber la hora.
long startTime = System.currentTimeMillis();
//@ Method call
System.out.println("Total time [ms]: " + (System.currentTimeMillis() - startTime));
Puedes usar Perf4j . Muy buena utilidad. El uso es simple
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;
}
Puede encontrar más información en la Guía del desarrollador.
Edit: el proyecto parece muerto
Si quieres reloj de pared
long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;
Siempre hay la manera antigua:
long startTime = System.nanoTime();
methodToTime();
long endTime = System.nanoTime();
long duration = (endTime - startTime); //divide by 1000000 to get milliseconds.
Solo un pequeño giro, si no usa herramientas y quiere cronometrar métodos con un tiempo de ejecución bajo: ejecútelo varias veces, cada vez que duplique la cantidad de veces que se ejecuta hasta que alcance un segundo, más o menos. Por lo tanto, el tiempo de la Llamada a System.nanoTime y demás, ni la precisión de System.nanoTime afectan mucho el resultado.
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");
Por supuesto, se aplican las advertencias sobre el uso del reloj de pared: influencias de la compilación JIT, varios subprocesos / procesos, etc. Por lo tanto, primero debe ejecutar el método muchas veces primero, de modo que el compilador JIT haga su trabajo, y luego repita esta prueba varias veces y tome el tiempo de ejecución más bajo.
Spring proporciona una clase de utilidad org.springframework.util.StopWatch , según JavaDoc:
Cronómetro simple, que permite cronometrar una serie de tareas, exponiendo el tiempo total de ejecución y el tiempo de ejecución para cada tarea nombrada.
Uso:
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());
Salida:
StopWatch ''Performance Test Result'': running time (millis) = 12829
-----------------------------------------
ms % Task name
-----------------------------------------
11907 036% Method 1
00922 064% Method 2
Con Aspectos:
@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;
}
También podemos usar la clase StopWatch de Apache commons para medir el tiempo.
Código de muestra
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());
Usando la anotación AOP / AspectJ y @Loggable de jcabi-aspects puedes hacerlo fácil y compacto:
@Loggable(Loggable.DEBUG)
public String getSomeResult() {
// return some value
}
Cada llamada a este método se enviará al servicio de registro SLF4J con el nivel de registro DEBUG . Y cada mensaje de registro incluirá el tiempo de ejecución.
Utilice un generador de perfiles (JProfiler, Netbeans Profiler, Visual VM, Eclipse Profiler, etc.). Obtendrá los resultados más precisos y es el menos intrusivo. Utilizan el mecanismo JVM incorporado para la creación de perfiles, que también puede proporcionarle información adicional como seguimientos de pila, rutas de ejecución y resultados más completos si es necesario.
Cuando se utiliza un generador de perfiles totalmente integrado, es trivial al perfilar un método. Haga clic derecho, Perfilador -> Agregar a métodos de raíz. A continuación, ejecute el generador de perfiles como si estuviera haciendo una ejecución de prueba o un depurador.
Voy con la respuesta simple. Funciona para mi.
long startTime = System.currentTimeMillis();
doReallyLongThing();
long endTime = System.currentTimeMillis();
System.out.println("That took " + (endTime - startTime) + " milliseconds");
Funciona bastante bien. La resolución es, obviamente, solo en milisegundos, puedes hacerlo mejor con System.nanoTime (). Hay algunas limitaciones para ambos (segmentos de programación del sistema operativo, etc.) pero esto funciona bastante bien.
Promedio en un par de carreras (cuanto más mejor) y obtendrá una idea decente.
System.currentTimeMillis(); NO ES un buen enfoque para medir el rendimiento de sus algoritmos. Mide el tiempo total que experimenta como usuario mirando la pantalla de la computadora. Incluye también el tiempo consumido por todo lo demás que se ejecuta en su computadora en segundo plano. Esto podría marcar una gran diferencia en caso de que tenga muchos programas ejecutándose en su estación de trabajo.
El enfoque adecuado es usar el paquete java.lang.management .
Desde el sitio web http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking :
- "Tiempo de usuario" es el tiempo dedicado a ejecutar el propio código de su aplicación.
- "Tiempo del sistema" es el tiempo dedicado a ejecutar el código del sistema operativo en nombre de su aplicación (por ejemplo, para E / S).
getCpuTime() método getCpuTime() te da la suma de esos:
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;
}
}
System.nanoTime() es una utilidad del sistema bastante precisa para medir el tiempo de ejecución. Pero tenga cuidado, si está ejecutando en modo de programador preventivo (predeterminado), esta utilidad en realidad mide el tiempo de reloj de pared y no el tiempo de CPU. Por lo tanto, puede observar diferentes valores de tiempo de ejecución de una ejecución a otra, dependiendo de las cargas del sistema. Si buscas el tiempo de CPU, creo que ejecutar tu programa en modo de tiempo real hará el truco. Tienes que usar RT linux. Enlace: Programación en tiempo real con Linux.
Reunidos todos los caminos posibles juntos en un solo lugar.
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);
Sistema. 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 ) );
Format legible por humanos
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 Stopwatch JAR «Un objeto del cronómetro es medir el tiempo transcurrido en nanosegundos.
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 « StopWatch proporciona una API conveniente para los tiempos.
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 de Java 8 «Un objeto Duration representa un período de tiempo entre dos objetos Instant .
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 proporciona la clase de utilidad StopWatch para medir el tiempo transcurrido en Java.
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());
}
Salida:
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]
long startTime = System.currentTimeMillis();
// code goes here
long finishTime = System.currentTimeMillis();
long elapsedTime = finishTime - startTime; // elapsed time in milliseconds
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()));
}
}