Java计时器StopWatch实现方法代码实例

下面提供三种计时器的写法供大家参考，大家可以自行选择自己钟爱的使用。

写法一（Spring 包提供的计时器）：

import java.text.NumberFormat;import java.util.LinkedList;import java.util.List;/** * Simple stop watch, allowing for timing of a number of tasks, * exposing total running time and running time for each named task. * * <p>Conceals use of {@code System.currentTimeMillis()}, improving the * readability of application code and reducing the likelihood of calculation errors. * * <p>Note that this object is not designed to be thread-safe and does not * use synchronization. * * <p>This class is normally used to verify performance during proof-of-concepts * and in development, rather than as part of production applications. * * @author Rod Johnson * @author Juergen Hoeller * @author Sam Brannen * @since May 2, 2001 */public class StopWatch { /** * Identifier of this stop watch. * Handy when we have output from multiple stop watches * and need to distinguish between them in log or console output. */ private final String id; private boolean keepTaskList = true; private final List<TaskInfo> taskList = new LinkedList<TaskInfo>(); /** Start time of the current task */ private long startTimeMillis; /** Is the stop watch currently running? */ private boolean running; /** Name of the current task */ private String currentTaskName; private TaskInfo lastTaskInfo; private int taskCount; /** Total running time */ private long totalTimeMillis; /** * Construct a new stop watch. Does not start any task. */ public StopWatch() { this(''); } /** * Construct a new stop watch with the given id. * Does not start any task. * @param id identifier for this stop watch. * Handy when we have output from multiple stop watches * and need to distinguish between them. */ public StopWatch(String id) { this.id = id; } /** * Return the id of this stop watch, as specified on construction. * @return the id (empty String by default) * @since 4.2.2 * @see #StopWatch(String) */ public String getId() { return this.id; } /** * Determine whether the TaskInfo array is built over time. Set this to * 'false' when using a StopWatch for millions of intervals, or the task * info structure will consume excessive memory. Default is 'true'. */ public void setKeepTaskList(boolean keepTaskList) { this.keepTaskList = keepTaskList; } /** * Start an unnamed task. The results are undefined if {@link #stop()} * or timing methods are called without invoking this method. * @see #stop() */ public void start() throws IllegalStateException { start(''); } /** * Start a named task. The results are undefined if {@link #stop()} * or timing methods are called without invoking this method. * @param taskName the name of the task to start * @see #stop() */ public void start(String taskName) throws IllegalStateException { if (this.running) { throw new IllegalStateException('Can’t start StopWatch: it’s already running'); } this.running = true; this.currentTaskName = taskName; this.startTimeMillis = System.currentTimeMillis(); } /** * Stop the current task. The results are undefined if timing * methods are called without invoking at least one pair * {@code start()} / {@code stop()} methods. * @see #start() */ public void stop() throws IllegalStateException { if (!this.running) { throw new IllegalStateException('Can’t stop StopWatch: it’s not running'); } long lastTime = System.currentTimeMillis() - this.startTimeMillis; this.totalTimeMillis += lastTime; this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime); if (this.keepTaskList) { this.taskList.add(lastTaskInfo); } ++this.taskCount; this.running = false; this.currentTaskName = null; } /** * Return whether the stop watch is currently running. * @see #currentTaskName() */ public boolean isRunning() { return this.running; } /** * Return the name of the currently running task, if any. * @since 4.2.2 * @see #isRunning() */ public String currentTaskName() { return this.currentTaskName; } /** * Return the time taken by the last task. */ public long getLastTaskTimeMillis() throws IllegalStateException { if (this.lastTaskInfo == null) { throw new IllegalStateException('No tasks run: can’t get last task interval'); } return this.lastTaskInfo.getTimeMillis(); } /** * Return the name of the last task. */ public String getLastTaskName() throws IllegalStateException { if (this.lastTaskInfo == null) { throw new IllegalStateException('No tasks run: can’t get last task name'); } return this.lastTaskInfo.getTaskName(); } /** * Return the last task as a TaskInfo object. */ public TaskInfo getLastTaskInfo() throws IllegalStateException { if (this.lastTaskInfo == null) { throw new IllegalStateException('No tasks run: can’t get last task info'); } return this.lastTaskInfo; } /** * Return the total time in milliseconds for all tasks. */ public long getTotalTimeMillis() { return this.totalTimeMillis; } /** * Return the total time in seconds for all tasks. */ public double getTotalTimeSeconds() { return this.totalTimeMillis / 1000.0; } /** * Return the number of tasks timed. */ public int getTaskCount() { return this.taskCount; } /** * Return an array of the data for tasks performed. */ public TaskInfo[] getTaskInfo() { if (!this.keepTaskList) { throw new UnsupportedOperationException('Task info is not being kept!'); } return this.taskList.toArray(new TaskInfo[this.taskList.size()]); } /** * Return a short description of the total running time. */ public String shortSummary() { return 'StopWatch ’' + getId() + '’: running time (millis) = ' + getTotalTimeMillis(); } /** * Return a string with a table describing all tasks performed. * For custom reporting, call getTaskInfo() and use the task info directly. */ public String prettyPrint() { StringBuilder sb = new StringBuilder(shortSummary()); sb.append(’n’); if (!this.keepTaskList) { sb.append('No task info kept'); } else { sb.append('-----------------------------------------n'); sb.append('ms % Task namen'); sb.append('-----------------------------------------n'); NumberFormat nf = NumberFormat.getNumberInstance(); nf.setMinimumIntegerDigits(5); nf.setGroupingUsed(false); NumberFormat pf = NumberFormat.getPercentInstance(); pf.setMinimumIntegerDigits(3); pf.setGroupingUsed(false); for (TaskInfo task : getTaskInfo()) {sb.append(nf.format(task.getTimeMillis())).append(' ');sb.append(pf.format(task.getTimeSeconds() / getTotalTimeSeconds())).append(' ');sb.append(task.getTaskName()).append('n'); } } return sb.toString(); } /** * Return an informative string describing all tasks performed * For custom reporting, call {@code getTaskInfo()} and use the task info directly. */ @Override public String toString() { StringBuilder sb = new StringBuilder(shortSummary()); if (this.keepTaskList) { for (TaskInfo task : getTaskInfo()) {sb.append('; [').append(task.getTaskName()).append('] took ').append(task.getTimeMillis());long percent = Math.round((100.0 * task.getTimeSeconds()) / getTotalTimeSeconds());sb.append(' = ').append(percent).append('%'); } } else { sb.append('; no task info kept'); } return sb.toString(); } /** * Inner class to hold data about one task executed within the stop watch. */ public static final class TaskInfo { private final String taskName; private final long timeMillis; TaskInfo(String taskName, long timeMillis) { this.taskName = taskName; this.timeMillis = timeMillis; } /** * Return the name of this task. */ public String getTaskName() { return this.taskName; } /** * Return the time in milliseconds this task took. */ public long getTimeMillis() { return this.timeMillis; } /** * Return the time in seconds this task took. */ public double getTimeSeconds() { return (this.timeMillis / 1000.0); } }}

下面写一个调用：

public static void main(String[] args) throws InterruptedException {// StopWatchTest.test0(); StopWatchTest.test1();}public static void test1() throws InterruptedException { StopWatch sw = new StopWatch('test'); sw.start('task1'); // do something Thread.sleep(100); sw.stop(); sw.start('task2'); // do something Thread.sleep(200); sw.stop(); System.out.println('sw.prettyPrint()~~~~~~~~~~~~~~~~~'); System.out.println(sw.prettyPrint());}

运行结果：

sw.prettyPrint()~~~~~~~~~~~~~~~~~StopWatch ’test’: running time (millis) = 308-----------------------------------------ms % Task name-----------------------------------------00104 034% task100204 066% task2---------------------

start开始记录，stop停止记录，然后通过StopWatch的prettyPrint方法，可直观的输出代码执行耗时，以及执行时间百分比，瞬间感觉比之前的方式高大上了一个档次。

 除此之外，还有以下两个方法shortSummary,getTotalTimeMillis，查看程序执行时间。

写法二（apache.commons实现的计时器）：

import java.util.concurrent.TimeUnit;/** * <p> * <code>StopWatch</code> provides a convenient API for timings. * </p> * * <p> * To start the watch, call {@link #start()} or {@link StopWatch#createStarted()}. At this point you can: * </p> * <ul> * <li>{@link #split()} the watch to get the time whilst the watch continues in the background. {@link #unsplit()} will * remove the effect of the split. At this point, these three options are available again.</li> * <li>{@link #suspend()} the watch to pause it. {@link #resume()} allows the watch to continue. Any time between the * suspend and resume will not be counted in the total. At this point, these three options are available again.</li> * <li>{@link #stop()} the watch to complete the timing session.</li> * </ul> * * <p> * It is intended that the output methods {@link #toString()} and {@link #getTime()} should only be called after stop, * split or suspend, however a suitable result will be returned at other points. * </p> * * <p> * NOTE: As from v2.1, the methods protect against inappropriate calls. Thus you cannot now call stop before start, * resume before suspend or unsplit before split. * </p> * * <p> * 1. split(), suspend(), or stop() cannot be invoked twice<br> * 2. unsplit() may only be called if the watch has been split()<br> * 3. resume() may only be called if the watch has been suspend()<br> * 4. start() cannot be called twice without calling reset() * </p> * * <p>This class is not thread-safe</p> * * @since 2.0 */public class StopWatch { private static final long NANO_2_MILLIS = 1000000L; /** * Provides a started stopwatch for convenience. * * @return StopWatch a stopwatch that’s already been started. * * @since 3.5 */ public static StopWatch createStarted() { final StopWatch sw = new StopWatch(); sw.start(); return sw; } /** * Enumeration type which indicates the status of stopwatch. */ private enum State { UNSTARTED { @Override boolean isStarted() {return false; } @Override boolean isStopped() {return true; } @Override boolean isSuspended() {return false; } }, RUNNING { @Override boolean isStarted() {return true; } @Override boolean isStopped() {return false; } @Override boolean isSuspended() {return false; } }, STOPPED { @Override boolean isStarted() {return false; } @Override boolean isStopped() {return true; } @Override boolean isSuspended() {return false; } }, SUSPENDED { @Override boolean isStarted() {return true; } @Override boolean isStopped() {return false; } @Override boolean isSuspended() {return true; } }; /** * <p> * The method is used to find out if the StopWatch is started. A suspended * StopWatch is also started watch. * </p> * @return boolean * If the StopWatch is started. */ abstract boolean isStarted(); /** * <p> * This method is used to find out whether the StopWatch is stopped. The * stopwatch which’s not yet started and explicitly stopped stopwatch is * considered as stopped. * </p> * * @return boolean * If the StopWatch is stopped. */ abstract boolean isStopped(); /** * <p> * This method is used to find out whether the StopWatch is suspended. * </p> * * @return boolean * If the StopWatch is suspended. */ abstract boolean isSuspended(); } /** * Enumeration type which indicates the split status of stopwatch. */ private enum SplitState { SPLIT, UNSPLIT } /** * The current running state of the StopWatch. */ private State runningState = State.UNSTARTED; /** * Whether the stopwatch has a split time recorded. */ private SplitState splitState = SplitState.UNSPLIT; /** * The start time. */ private long startTime; /** * The start time in Millis - nanoTime is only for elapsed time so we * need to also store the currentTimeMillis to maintain the old * getStartTime API. */ private long startTimeMillis; /** * The stop time. */ private long stopTime; /** * <p> * Constructor. * </p> */ public StopWatch() { super(); } /** * <p> * Start the stopwatch. * </p> * * <p> * This method starts a new timing session, clearing any previous values. * </p> * * @throws IllegalStateException * if the StopWatch is already running. */ public void start() { if (this.runningState == State.STOPPED) { throw new IllegalStateException('Stopwatch must be reset before being restarted. '); } if (this.runningState != State.UNSTARTED) { throw new IllegalStateException('Stopwatch already started. '); } this.startTime = System.nanoTime(); this.startTimeMillis = System.currentTimeMillis(); this.runningState = State.RUNNING; } /** * <p> * Stop the stopwatch. * </p> * * <p> * This method ends a new timing session, allowing the time to be retrieved. * </p> * * @throws IllegalStateException * if the StopWatch is not running. */ public void stop() { if (this.runningState != State.RUNNING && this.runningState != State.SUSPENDED) { throw new IllegalStateException('Stopwatch is not running. '); } if (this.runningState == State.RUNNING) { this.stopTime = System.nanoTime(); } this.runningState = State.STOPPED; } /** * <p> * Resets the stopwatch. Stops it if need be. * </p> * * <p> * This method clears the internal values to allow the object to be reused. * </p> */ public void reset() { this.runningState = State.UNSTARTED; this.splitState = SplitState.UNSPLIT; } /** * <p> * Split the time. * </p> * * <p> * This method sets the stop time of the watch to allow a time to be extracted. The start time is unaffected, * enabling {@link #unsplit()} to continue the timing from the original start point. * </p> * * @throws IllegalStateException * if the StopWatch is not running. */ public void split() { if (this.runningState != State.RUNNING) { throw new IllegalStateException('Stopwatch is not running. '); } this.stopTime = System.nanoTime(); this.splitState = SplitState.SPLIT; } /** * <p> * Remove a split. * </p> * * <p> * This method clears the stop time. The start time is unaffected, enabling timing from the original start point to * continue. * </p> * * @throws IllegalStateException * if the StopWatch has not been split. */ public void unsplit() { if (this.splitState != SplitState.SPLIT) { throw new IllegalStateException('Stopwatch has not been split. '); } this.splitState = SplitState.UNSPLIT; } /** * <p> * Suspend the stopwatch for later resumption. * </p> * * <p> * This method suspends the watch until it is resumed. The watch will not include time between the suspend and * resume calls in the total time. * </p> * * @throws IllegalStateException * if the StopWatch is not currently running. */ public void suspend() { if (this.runningState != State.RUNNING) { throw new IllegalStateException('Stopwatch must be running to suspend. '); } this.stopTime = System.nanoTime(); this.runningState = State.SUSPENDED; } /** * <p> * Resume the stopwatch after a suspend. * </p> * * <p> * This method resumes the watch after it was suspended. The watch will not include time between the suspend and * resume calls in the total time. * </p> * * @throws IllegalStateException * if the StopWatch has not been suspended. */ public void resume() { if (this.runningState != State.SUSPENDED) { throw new IllegalStateException('Stopwatch must be suspended to resume. '); } this.startTime += System.nanoTime() - this.stopTime; this.runningState = State.RUNNING; } /** * <p> * Get the time on the stopwatch. * </p> * * <p> * This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. * </p> * * @return the time in milliseconds */ public long getTime() { return getNanoTime() / NANO_2_MILLIS; } /** * <p> * Get the time on the stopwatch in the specified TimeUnit. * </p> * * <p> * This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. The resulting time will be expressed in the desired TimeUnit with any remainder rounded down. * For example, if the specified unit is {@code TimeUnit.HOURS} and the stopwatch time is 59 minutes, then the * result returned will be {@code 0}. * </p> * * @param timeUnit the unit of time, not null * @return the time in the specified TimeUnit, rounded down * @since 3.5 */ public long getTime(final TimeUnit timeUnit) { return timeUnit.convert(getNanoTime(), TimeUnit.NANOSECONDS); } /** * <p> * Get the time on the stopwatch in nanoseconds. * </p> * * <p> * This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. * </p> * * @return the time in nanoseconds * @since 3.0 */ public long getNanoTime() { if (this.runningState == State.STOPPED || this.runningState == State.SUSPENDED) { return this.stopTime - this.startTime; } else if (this.runningState == State.UNSTARTED) { return 0; } else if (this.runningState == State.RUNNING) { return System.nanoTime() - this.startTime; } throw new RuntimeException('Illegal running state has occurred.'); } /** * <p> * Get the split time on the stopwatch. * </p> * * <p> * This is the time between start and latest split. * </p> * * @return the split time in milliseconds * * @throws IllegalStateException * if the StopWatch has not yet been split. * @since 2.1 */ public long getSplitTime() { return getSplitNanoTime() / NANO_2_MILLIS; } /** * <p> * Get the split time on the stopwatch in nanoseconds. * </p> * * <p> * This is the time between start and latest split. * </p> * * @return the split time in nanoseconds * * @throws IllegalStateException * if the StopWatch has not yet been split. * @since 3.0 */ public long getSplitNanoTime() { if (this.splitState != SplitState.SPLIT) { throw new IllegalStateException('Stopwatch must be split to get the split time. '); } return this.stopTime - this.startTime; } /** * Returns the time this stopwatch was started. * * @return the time this stopwatch was started * @throws IllegalStateException * if this StopWatch has not been started * @since 2.4 */ public long getStartTime() { if (this.runningState == State.UNSTARTED) { throw new IllegalStateException('Stopwatch has not been started'); } // System.nanoTime is for elapsed time return this.startTimeMillis; } /** * <p> * Gets a summary of the time that the stopwatch recorded as a string. * </p> * * <p> * The format used is ISO 8601-like, <i>hours</i>:<i>minutes</i>:<i>seconds</i>.<i>milliseconds</i>. * </p> * * @return the time as a String */ @Override public String toString() { return DurationFormatUtils.formatDurationHMS(getTime()); } /** * <p> * Gets a summary of the split time that the stopwatch recorded as a string. * </p> * * <p> * The format used is ISO 8601-like, <i>hours</i>:<i>minutes</i>:<i>seconds</i>.<i>milliseconds</i>. * </p> * * @return the split time as a String * @since 2.1 */ public String toSplitString() { return DurationFormatUtils.formatDurationHMS(getSplitTime()); } /** * <p> * The method is used to find out if the StopWatch is started. A suspended * StopWatch is also started watch. * </p> * * @return boolean * If the StopWatch is started. * @since 3.2 */ public boolean isStarted() { return runningState.isStarted(); } /** * <p> * This method is used to find out whether the StopWatch is suspended. * </p> * * @return boolean * If the StopWatch is suspended. * @since 3.2 */ public boolean isSuspended() { return runningState.isSuspended(); } /** * <p> * This method is used to find out whether the StopWatch is stopped. The * stopwatch which’s not yet started and explicitly stopped stopwatch is * considered as stopped. * </p> * * @return boolean * If the StopWatch is stopped. * @since 3.2 */ public boolean isStopped() { return runningState.isStopped(); }}

写法三（Scala函数写法）：

import org.slf4j.LoggerFactory/** * 类功能描述：Debug日志追踪 * * @author barry create at 18-8-29 下午3:41 * @version 1.0.0 */object Debug { val LOGGER = LoggerFactory.getLogger(getClass) val counter = collection.mutable.Map[String, Int]() // label -> count val times = collection.mutable.Map[String, Long]() // label - time(ns) /** *追踪代码块 * @param label 标签名 * @param codeBlock 代码块 * @tparam T 返回结果类型 * @return */ def trace[T](label: String)(codeBlock: => T) = { val t0 = System.nanoTime() val result = codeBlock val t1 = System.nanoTime() counter.get(label).map(_counter => counter.put(label, _counter + 1)).orElse(counter.put(label, 1)) times.get(label).map(cost => times.put(label, cost + (t1 - t0))).orElse(times.put(label, t1 - t0)) result } /** * 打印日志 */ def info(): Unit = { LOGGER.warn('FinallyDone...') LOGGER.warn(s'counter:${counter}') LOGGER.warn(s'times:${times.map { case (label, cost) => (label, cost / 1000000)}}ms') } /** * 重新计数 */ def reset(): Unit = { counter.clear() times.clear() }}

参考下面测试代码：

java版本：

/** * @author WangXueXing create at 19-7-31 下午1:46 * @version 1.0.0 */public class StopWatchDemo { public static void main(String[] args){ Debug.trace('方法1调用次数及用时', ()->{ try {Thread.sleep(2000); } catch (InterruptedException e) {e.printStackTrace(); } return ''; }); Debug.trace('方法1调用次数及用时', ()->{ try {Thread.sleep(2000); } catch (InterruptedException e) {e.printStackTrace(); } return ''; }); Debug.trace('方法2调用次数及用时', ()->{ try {Thread.sleep(2000); } catch (InterruptedException e) {e.printStackTrace(); } return 10; }); Debug.info(); }}

输出结果：

15:29:32.228 [main] WARN test.Debug$ - FinallyDone...15:29:32.361 [main] WARN test.Debug$ - counter:Map(方法2调用次数及用时 -> 1, 方法1调用次数及用时 -> 2)15:29:32.364 [main] WARN test.Debug$ - times:Map(方法2调用次数及用时 -> 2000, 方法1调用次数及用时 -> 4000)ms

scala版本：

/** * @author WangXueXing create at 19-8-1 下午3:40 * @version 1.0.0 */object StopWatchTest { def main(args: Array[String]): Unit = { Debug.trace('方法1调用次数及用时')( Thread.sleep(200)) Debug.trace('方法1调用次数及用时')( Thread.sleep(200)) Debug.trace('方法2调用次数及用时')( Thread.sleep(200)) Debug.info() }}

输出结果：

15:43:58.601 [main] WARN test.stopwatch.Debug$ - FinallyDone...15:43:58.735 [main] WARN test.stopwatch.Debug$ - counter:Map(方法2调用次数及用时 -> 1, 方法1调用次数及用时 -> 2)15:43:58.739 [main] WARN test.stopwatch.Debug$ - times:Map(方法2调用次数及用时 -> 200, 方法1调用次数及用时 -> 400)ms

对比java版本与scala版本，是不是看到scala的简洁及强大了吧！

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持好吧啦网。