segundos - medir el tiempo de ejecucion de un metodo en java

Medir el tiempo de ejecución de un método Java

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo cronometro la ejecución de un método en Java? 37 respuestas

¿Cómo calculo el tiempo necesario para la ejecución de un método en Java?

Answer 1

Como se propone, nanoTime () es muy preciso en escalas de tiempo cortas. Cuando se requiere esta precisión, debe tener cuidado con lo que realmente mide. Especialmente para no medir el nanotime.

long start1 = System.nanoTime();
// maybe add here a call to a return to remove call up time, too.
// Avoid optimization 
long start2 = System.nanoTime();
myCall(); 
long stop = System.nanoTime();
long diff = stop - 2*start2 + start1;

System.out.println(diff + " ns");

Por cierto, medirá diferentes valores para la misma llamada debido a

• otra carga en su computadora (fondo, red, movimiento del mouse, interrupciones, cambio de tareas, hilos)
• Rellenos de caché (frío, caliente)
• compilación de jit (sin optimización, impacto de rendimiento debido a la ejecución del compilador, aumento de rendimiento debido al compilador (pero a veces el código con jit es más lento que sin!))

Answer 2

Compruebe esto: System.currentTimeMillis .

Con esto puedes calcular el tiempo de tu método haciendo:

long start = System.currentTimeMillis();
class.method();
long time = System.currentTimeMillis() - start;

Answer 3

De hecho, la nanotima ni siquiera es buena para el tiempo transcurrido porque se aleja significativamente más que la actual TimeMillis. Además, la nanotima tiende a proporcionar una precisión excesiva a expensas de la precisión. Por lo tanto, es altamente inconsistente y necesita refinamiento.

En cualquier momento del proceso de medición, currentTimeMillis (aunque es casi tan malo), funciona mejor en términos de precisión de equilibrio.

Answer 4

En caso de que desarrolles aplicaciones para Android , deberías probar la clase TimingLogger .
Eche un vistazo a estos artículos que describen el uso de la clase auxiliar TimingLogger :

• Medición del rendimiento en el SDK de Android (27.09.2010)
• Descubriendo la API de Android - Parte 1 (03.01.2017)

Answer 5

Es posible que desee pensar en la programación orientada a aspectos. No quieres ensuciar tu código con tiempos. Quieres poder apagarlos y activarlos declarativamente.

Si usa Spring, eche un vistazo a su clase MethodInterceptor .

Answer 6

Para ser más precisos, usaría el método nanoTime() lugar de currentTimeMillis() :

long startTime = System.nanoTime();
myCall(); 
long stopTime = System.nanoTime();
System.out.println(stopTime - startTime);

En Java 8 (el formato de salida es ISO-8601):

Instant start = Instant.now();
Thread.sleep(63553);
Instant end = Instant.now();
System.out.println(Duration.between(start, end)); // prints PT1M3.553S

Stopwatch guayaba:

Stopwatch stopwatch = Stopwatch.createStarted();
myCall();
stopwatch.stop(); // optional
System.out.println("Time elapsed for myCall() is "+ stopwatch.elapsed(MILLISECONDS));

Answer 7

Puede tomar instantáneas de marca de tiempo antes y después, luego repetir los experimentos varias veces para promediar los resultados . También hay perfiladores que pueden hacer esto por usted.

Del libro "Java Platform Performance: Strategies and Tactics":

Con System.currentTimeMillis ()

class TimeTest1 {
   public static void main(String[] args) {

      long startTime = System.currentTimeMillis();

      long total = 0;
      for (int i = 0; i < 10000000; i++) {
         total += i;
      }

      long stopTime = System.currentTimeMillis();
      long elapsedTime = stopTime - startTime;
      System.out.println(elapsedTime);
   }
}

Con una clase de cronómetro

Puede usar esta clase StopWatch , llamar a start() y stop antes y después del método.

class TimeTest2 {
   public static void main(String[] args) {

      Stopwatch timer = new Stopwatch().start();

      long total = 0;
      for (int i = 0; i < 10000000; i++) {
         total += i;
      }

      timer.stop();
      System.out.println(timer.getElapsedTime());
   }
}

Ver here

NetBeans Profiler:

Aplicación Rendimiento Aplicación

Perfiles de rendimiento a nivel de método de rendimiento de CPU (tiempo de ejecución) Puede elegir perfilar la aplicación completa o una parte de la aplicación.

Ver here

Answer 8

Si actualmente está escribiendo la aplicación, entonces la respuesta es usar System.currentTimeMillis o System.nanoTime para el propósito tal como lo System.nanoTime las personas mencionadas anteriormente.

Pero si ya ha escrito el código y no desea cambiarlo, es mejor utilizar los interceptores de método de Spring. Así, por ejemplo, su servicio es:

public class MyService { 
    public void doSomething() {
        for (int i = 1; i < 10000; i++) {
            System.out.println("i=" + i);
        }
    }
}

Para evitar cambiar el servicio, puede escribir su propio método interceptor:

public class ServiceMethodInterceptor implements MethodInterceptor {
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = methodInvocation.proceed();
        long duration = System.currentTimeMillis() - startTime;
        Method method = methodInvocation.getMethod();
        String methodName = method.getDeclaringClass().getName() + "." + method.getName();
        System.out.println("Method ''" + methodName + "'' took " + duration + " milliseconds to run");
        return null;
    }
}

También hay API de código abierto disponibles para Java, por ejemplo, BTrace . o el generador de perfiles Netbeans como se sugiere anteriormente por @bakkal y @Saikikos. Gracias.