Java计时器StopWatch如何实现 Java计时器StopWatch实现代码实例
Java计时器StopWatch如何实现？本篇文章小编给大家分享一下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. * *Conceals use of {@code System.currentTimeMillis()}, improving the * readability of application code and reducing the likelihood of calculation errors. * *
Note that this object is not designed to be thread-safe and does not * use synchronization. * *
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
taskList = new LinkedList (); /** 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% task1
00204 066% task2
---------------------
start开始记录，stop停止记录，然后通过StopWatch的prettyPrint方法，可直观的输出代码执行耗时，以及执行时间百分比，瞬间感觉比之前的方式高大上了一个档次。
除此之外，还有以下两个方法shortSummary,getTotalTimeMillis，查看程序执行时间。
写法二（apache.commons实现的计时器）：
import java.util.concurrent.TimeUnit; /** **
* *StopWatchprovides a convenient API for timings. ** To start the watch, call {@link #start()} or {@link StopWatch#createStarted()}. At this point you can: *
*
-
*
- {@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. *
- {@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. *
- {@link #stop()} the watch to complete the timing session. *
* 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. *
* ** 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. *
* *
* 1. split(), suspend(), or stop() cannot be invoked twice
* 2. unsplit() may only be called if the watch has been split()
* 3. resume() may only be called if the watch has been suspend()
* 4. start() cannot be called twice without calling reset()
*
This class is not thread-safe
* * @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; } }; /** ** The method is used to find out if the StopWatch is started. A suspended * StopWatch is also started watch. *
* @return boolean * If the StopWatch is started. */ abstract boolean isStarted(); /** ** 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. *
* * @return boolean * If the StopWatch is stopped. */ abstract boolean isStopped(); /** ** This method is used to find out whether the StopWatch is suspended. *
* * @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; /** ** Constructor. *
*/ public StopWatch() { super(); } /** ** Start the stopwatch. *
* ** This method starts a new timing session, clearing any previous values. *
* * @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; } /** ** Stop the stopwatch. *
* ** This method ends a new timing session, allowing the time to be retrieved. *
* * @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; } /** ** Resets the stopwatch. Stops it if need be. *
* ** This method clears the internal values to allow the object to be reused. *
*/ public void reset() { this.runningState = State.UNSTARTED; this.splitState = SplitState.UNSPLIT; } /** ** Split the time. *
* ** 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. *
* * @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; } /** ** Remove a split. *
* ** This method clears the stop time. The start time is unaffected, enabling timing from the original start point to * continue. *
* * @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; } /** ** Suspend the stopwatch for later resumption. *
* ** 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. *
* * @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; } /** ** Resume the stopwatch after a suspend. *
* ** 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. *
* * @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; } /** ** Get the time on the stopwatch. *
* ** This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. *
* * @return the time in milliseconds */ public long getTime() { return getNanoTime() / NANO_2_MILLIS; } /** ** Get the time on the stopwatch in the specified TimeUnit. *
* ** 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}. *
* * @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); } /** ** Get the time on the stopwatch in nanoseconds. *
* ** This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. *
* * @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."); } /** ** Get the split time on the stopwatch. *
* ** This is the time between start and latest split. *
* * @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; } /** ** Get the split time on the stopwatch in nanoseconds. *
* ** This is the time between start and latest split. *
* * @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; } /** ** Gets a summary of the time that the stopwatch recorded as a string. *
* ** The format used is ISO 8601-like, hours:minutes:seconds.milliseconds. *
* * @return the time as a String */ @Override public String toString() { return DurationFormatUtils.formatDurationHMS(getTime()); } /** ** Gets a summary of the split time that the stopwatch recorded as a string. *
* ** The format used is ISO 8601-like, hours:minutes:seconds.milliseconds. *
* * @return the split time as a String * @since 2.1 */ public String toSplitString() { return DurationFormatUtils.formatDurationHMS(getSplitTime()); } /** ** The method is used to find out if the StopWatch is started. A suspended * StopWatch is also started watch. *
* * @return boolean * If the StopWatch is started. * @since 3.2 */ public boolean isStarted() { return runningState.isStarted(); } /** ** This method is used to find out whether the StopWatch is suspended. *
* * @return boolean * If the StopWatch is suspended. * @since 3.2 */ public boolean isSuspended() { return runningState.isSuspended(); } /** ** 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. *
* * @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的简洁及强大了吧！
