如何计算方法在Java中的执行时间？

这可能不是你想要我说的,但这是AOP的一个很好的用法.在你的方法周围打一个代理拦截器,并在那里做时间.

可悲的是,AOP的内容,原因和方式超出了这个答案的范围,但这就是我可能做到的.

编辑:如果您热衷于此,这里有一个指向 Spring AOP 的链接,可以帮助您入门.这是Iive最容易实现的AOP实现.

另外,鉴于其他人的非常简单的建议,我应该补充一点,AOP适用于你不想要时间来侵入代码的东西.但在许多情况下,这种简单易行的方法很好.

System.currentTimeMillis();这不是衡量算法性能的好方法.它衡量用户观看计算机屏幕时的总体时间.它还包括在后台运行在计算机上的所有其他内容所消耗的时间.如果您的工作站上运行了很多程序,这可能会产生巨大的差异.

正确的方法是使用java.lang.management包.

来自http://nadeausoftware.com/articles/2008/03/java_tip_how_get_cpu_and_user_time_benchmarking网站:

"用户时间"是运行应用程序自己的代码所花费的时间.

"系统时间"是代表您的应用程序运行OS代码所花费的时间(例如I/O).

getCpuTime() 方法给你的总和:

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;
    }

}

使用Java 8,您可以使用每种常规方法执行类似的操作:

Object returnValue = TimeIt.printTime(() -> methodeWithReturnValue());
//do stuff with your returnValue

与TimeIt像:

public class TimeIt {

public static  T printTime(Callable 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;
}
}

使用这种方法,您可以在代码中的任何位置轻松进行时间测量而不会破坏它.在这个简单的例子中,我只打印时间.你可以为TimeIt添加一个Switch,例如只在DebugMode中打印时间.

如果你正在使用Function,你可以做这样的事情:

Function 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  Function printTime2(Function task) {
    return (t) -> {
        long startTime = System.currentTimeMillis();
        R apply = task.apply(t);
        System.out.print((System.currentTimeMillis() - startTime) / 1000d
                + "s");
        return apply;
    };
}

我们也可以使用Apache公共的StopWatch类来测量时间.

示例代码

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());

如果你不使用工具并且想要以低执行时间计时方法,那么只需要很小的一点:执行它多次,每次执行的次数加倍,直到你达到一秒左右.因此,调用System.nanoTime等的时间,以及System.nanoTime的准确性确实会对结果产生很大影响.

    int runs = 0, runsPerRound = 10;
    long begin = System.nanoTime(), end;
    do {
        for (int i=0; i end - begin);
    System.out.println("Time for timedMethod() is " + 
        0.000000001 * (end-begin) / runs + " seconds");

当然,关于使用挂钟的注意事项适用:JIT编译的影响,多线程/进程等.因此,您需要首先执行该方法很多次,这样JIT编译器才能完成其工作,然后多次重复此测试并执行最短的执行时间.

我们正在使用AspectJ和Java注释来实现此目的.如果我们需要了解方法的执行时间,我们可以简单地注释它.更高级的版本可以使用可在运行时启用和禁用的自己的日志级别.

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;
  }
  [...]
}

真的很好的代码.

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
   *  "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:Microbenchmark Suite是一项OpenJDK提案,旨在:

在JDK源代码中添加一套基本的微基准测试,使开发人员可以轻松运行现有的微基准测试并创建新的基准测试.

这个提议没有为Java 9做好准备,但可能会在以后添加.

与此同时,您可能需要查看提案所基于的Java Microbenchmark Harness(JMH)项目.

你可以使用Perf4j.很酷的实用程序.用法很简单

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; 
}

更多信息可以在开发人员指南中找到

编辑:项目似乎已经死了

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()));
    }

}

我基本上做了这方面的变化,但考虑到热点编译的工作原理,如果你想获得准确的结果,你需要抛出前几个测量并确保你在现实世界中使用该方法(特定于应用程序)应用程序.

如果JIT决定编译它,你的数字会有很大差异.所以请注意

使用@Loggable来自jcabi-aspects的 AOP/AspectJ和注释,您可以轻松简洁地完成:

@Loggable(Loggable.DEBUG)
public String getSomeResult() {
  // return some value
}

每次调用此方法都将发送到具有DEBUG日志记录级别的SLF4J日志记录工具.每条日志消息都包含执行时间.

有几种方法可以做到这一点.我通常会回到使用这样的东西:

long start = System.currentTimeMillis();
// ... do something ...
long end = System.currentTimeMillis();

与System.nanoTime()相同的事情;

对于基准测试方面的更多内容,似乎还有这个:http://jetm.void.fm/从未尝试过.

根据JavaDoc，Spring提供了一个实用程序类org.springframework.util.StopWatch：

简单的秒表，允许为多个任务计时，公开总运行时间和每个命名任务的运行时间。

用法：

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());

输出：

StopWatch 'Performance Test Result': running time (millis) = 12829
-----------------------------------------
ms     %     Task name
-----------------------------------------
11907  036%  Method 1
00922  064%  Method 2

与方面：

@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;
}

我已经编写了一种方法，以一种易于阅读的形式打印该方法的执行时间。例如，要计算100万的阶乘，大约需要9分钟。因此执行时间被打印为：

Execution Time: 9 Minutes, 36 Seconds, 237 MicroSeconds, 806193 NanoSeconds

代码在这里：

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");
    }
}

如果您想要挂钟时间

long start_time = System.currentTimeMillis();
object.method();
long end_time = System.currentTimeMillis();
long execution_time = end_time - start_time;

正如“ skaffman”所说，使用AOP OR可以使用运行时字节码编织，就像单元测试方法覆盖工具用来透明地将计时信息添加到调用的方法一样。

您可以查看Emma等开放源代码工具所使用的代码（http://downloads.sourceforge.net/emma/emma-2.0.5312-src.zip?modtime=1118607545&big_mirror=0）。另一个开放源代码覆盖工具是http://prdownloads.sourceforge.net/cobertura/cobertura-1.9-src.zip?download。

如果您最终设法按照自己的意愿去做，请。与您的蚂蚁任务/罐子在这里与社区共享。

您可以使用提供各种测量仪器的Metrics库。添加依赖项：

    
        io.dropwizard.metrics
        metrics-core
        ${metrics.version}
    

并根据您的环境进行配置。

可以使用@Timed注释方法：

@Timed
public void exampleMethod(){
    // some code
}

或用Timer包装的一段代码：

final Timer timer = metricsRegistry.timer("some_name");
final Timer.Context context = timer.time();
// timed code
context.stop();

汇总指标可以导出到控制台，JMX，CSV或其他。

@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