Java的秒表类

你应该使用哪个Java类来进行时间性能测量?

(可以使用任何date/时间类,但我要问的原因是.Net中有一个指定的秒表类用于此目的)

Spring框架有一个很好的StopWatch类 :

 StopWatch stopWatch = new StopWatch("My Stop Watch"); stopWatch.start("initializing"); Thread.sleep(2000); // simulated work stopWatch.stop(); stopWatch.start("processing"); Thread.sleep(5000); // simulated work stopWatch.stop(); stopWatch.start("finalizing"); Thread.sleep(3000); // simulated work stopWatch.stop(); System.out.println(stopWatch.prettyPrint()); 

这产生:

     StopWatch'我的秒表':运行时间(毫秒)= 10000
     -----------------------------------------
     ms%任务名称
     -----------------------------------------
     02000 020%初始化
     05000 050%处理
     03000 030%定稿

java.lang.System.nanoTime()

或者你可以使用在Apache公共版中提供的StopWatch。 这个类使用java.lang.System.currentTimeMillis()

http://commons.apache.org/lang/api-release/org/apache/commons/lang/time/StopWatch.html

检查perf4j。 spring的秒表主要是为了本地的发展。 Perf4j既可以支持您的POCtypes时序,也可以支持生产环境。

这是一个示例,如何使用StopWatch通过注释专用方法来设置多个测量。 使用非常有用和非常简单的方法来测量例如多个embedded式呼叫/操作的服务呼叫等等。

StopWatchHierarchy

 package ch.vii.spring.aop; import java.util.Arrays; import org.aopalliance.intercept.MethodInterceptor; import org.aopalliance.intercept.MethodInvocation; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Component; import org.springframework.util.StopWatch; @Component public class ProfilingMethodInterceptor implements MethodInterceptor { private static final Logger log = LoggerFactory.getLogger(ProfilingMethodInterceptor.class); public Object invoke(MethodInvocation invocation) throws Throwable { if (log.isInfoEnabled()) { String stopWatchName = invocation.getMethod().toGenericString(); StopWatchHierarchy stopWatch = StopWatchHierarchy.getStopWatchHierarchy(stopWatchName); String taskName = invocation.getMethod().getName(); stopWatch.start(taskName); try { return invocation.proceed(); } finally { stopWatch.stop(); } } else { return invocation.proceed(); } } static class StopWatchHierarchy { private static final ThreadLocal<StopWatchHierarchy> stopwatchLocal = new ThreadLocal<StopWatchHierarchy>(); private static final IndentStack indentStack = new IndentStack(); static StopWatchHierarchy getStopWatchHierarchy(String id) { StopWatchHierarchy stopWatch = stopwatchLocal.get(); if (stopWatch == null) { stopWatch = new StopWatchHierarchy(id); stopwatchLocal.set(stopWatch); } return stopWatch; } static void reset() { stopwatchLocal.set(null); } final StopWatch stopWatch; final Stack stack; StopWatchHierarchy(String id) { stopWatch = new StopWatch(id); stack = new Stack(); } void start(String taskName) { if (stopWatch.isRunning()) { stopWatch.stop(); } taskName = indentStack.get(stack.size) + taskName; stack.push(taskName); stopWatch.start(taskName); } void stop() { stopWatch.stop(); stack.pop(); if (stack.isEmpty()) { log.info(stopWatch.prettyPrint()); StopWatchHierarchy.reset(); } else { stopWatch.start(stack.get()); } } } static class Stack { private int size = 0; String elements[]; public Stack() { elements = new String[10]; } public void push(String e) { if (size == elements.length) { ensureCapa(); } elements[size++] = e; } public String pop() { String e = elements[--size]; elements[size] = null; return e; } public String get() { return elements[size - 1]; } public boolean isEmpty() { return size == 0; } private void ensureCapa() { int newSize = elements.length * 2; elements = Arrays.copyOf(elements, newSize); } } static class IndentStack { String elements[] = new String[0]; public String get(int index) { if (index >= elements.length) { ensureCapa(index + 10); } return elements[index]; } private void ensureCapa(int newSize) { int oldSize = elements.length; elements = Arrays.copyOf(elements, newSize); for (int i = oldSize; i < elements.length; i++) { elements[i] = new String(new char[i]).replace("\0", "| "); } } } } 

顾问

 package ch.vii.spring.aop; import java.lang.reflect.Method; import org.aopalliance.aop.Advice; import org.springframework.aop.Pointcut; import org.springframework.aop.support.AbstractPointcutAdvisor; import org.springframework.aop.support.StaticMethodMatcherPointcut; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class ProfilingAdvisor extends AbstractPointcutAdvisor { private static final long serialVersionUID = 1L; private final StaticMethodMatcherPointcut pointcut = new StaticMethodMatcherPointcut() { public boolean matches(Method method, Class<?> targetClass) { return method.isAnnotationPresent(ProfileExecution.class); } }; @Autowired private ProfilingMethodInterceptor interceptor; public Pointcut getPointcut() { return this.pointcut; } public Advice getAdvice() { return this.interceptor; } } 

ProfileExecution注释

 package ch.vii.spring.aop; import java.lang.annotation.ElementType; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) @Inherited public @interface ProfileExecution { } 

注释你的代码

 package ch.vii.spring; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import ch.vii.spring.aop.ProfileExecution; @Component public class Bean { @Autowired InnerBean innerBean; @ProfileExecution public void foo() { innerBean.innerFoo(); innerBean.innerFoo2(); innerBean.innerFoo(); } } public class InnerBean { @Autowired InnerInnerBean innerInnerBean; @ProfileExecution public void innerFoo() { } @ProfileExecution public void innerFoo2() { innerInnerBean.innerInnerFoo(); innerInnerBean.innerInnerFoo(); innerInnerBean.innerInnerFoo(); } } 

产量

 09:58:39.627 [main] INFO cvsaop.ProfilingMethodInterceptor - StopWatch 'public void ch.vii.spring.Bean.foo()': running time (millis) = 215 ----------------------------------------- ms % Task name ----------------------------------------- 00018 008 % foo 00026 012 % | innerFoo 00001 000 % foo 00016 007 % | innerFoo2 00038 018 % | | innerInnerFoo 00000 000 % | innerFoo2 00024 011 % | | innerInnerFoo 00028 013 % | innerFoo2 00024 011 % | | innerInnerFoo 00029 013 % | innerFoo2 00000 000 % foo 00011 005 % | innerFoo 00000 000 % foo 

您可以尝试System.currentTimeMillis() ,但是在一些众所周知的IDE(例如eclipse和netbeans)下也有一个很好的分析选项。 另外,远离IDE,您可以在性能测量任务中尝试单独的分析器 。 我认为通过使用分析器,你会得到比使用System.currentTimeMillis()更好的结果。

如果你只是想测量它,使用秒表类,或者也许只是一个秒表。

如果你想让它更快, 考虑这一点 。

最好的是使用System.nanoTime(),但是,如果你想得到Ticks(elapsed Ticks)像System.Diagnostics.Stopwatch那么你需要转换纳秒到Ticks(1 Tick = 100纳秒),然后开始转换毫秒,毫秒,秒,分钟,小时,然后最终将输出格式化为时间表示,例如Elapsed()方法之一(hh:mm:ss.sssssss),但是,看起来像Java中的date仅使用3毫秒(hh:mm:ss.sss),所以你也需要锻炼格式。

我为Java做了一个Stopwatch类,你可以从http://carlosqt.blogspot.com/2011/05/stopwatch-class-for-java.html

例:

 package stopwatchapp; import java.math.BigInteger; public class StopwatchApp { public static void main(String[] args) { Stopwatch timer = new Stopwatch(); timer.start(); Fibonacci(40); timer.stop(); System.out.println("Elapsed time in ticks: " + timer.getElapsedTicks()); System.out.println("Elapsed time in milliseconds: " + timer.getElapsedMilliseconds()); System.out.println("Elapsed time in seconds: " + timer.getElapsedSeconds()); System.out.println("Elapsed time in minutes: " + timer.getElapsedMinutes()); System.out.println("Elapsed time in hours: " + timer.getElapsedHours()); System.out.println("Elapsed time with format: " + timer.getElapsed()); } private static BigInteger Fibonacci(int n) { if (n < 2) return BigInteger.ONE; else return Fibonacci(n - 1).add(Fibonacci(n - 2)); } } 

输出:

 // Elapsed time in ticks: 33432284 // Elapsed time in milliseconds: 3343 // Elapsed time in seconds: 3 // Elapsed time in minutes: 0 // Elapsed time in hours: 0 // Elapsed time with format: 00:00:03.3432284 

希望这可以帮助。

 private void WaitTimer(long ms) { long t = 0; long x = System.currentTimeMillis(); while(t < ms) { t = System.currentTimeMillis() - x; } }