Spring计时器StopWatch使用详解 源码分析
前言
在我们日常开发中有时需要对某一个运算或者方法进行计时，以便我们来观察该运算或方法是否符合我们的预期。
在Spring中，为了统计任务的执行时间，开发了一个轻量级的计时器，它就是：StopWatch。StopWatch是一个轻量级的秒表，允许多个任务的计时，暴露每个命名任务的总运行时间和运行时间。隐藏使用System.currentTimeMillis()，提高应用程序代码的可读性并减少计算错误的可能性。
请注意，此对象并非线程安全，并且未使用同步修饰。从Spring 5.2开始以纳秒为单位进行统计。
基本使用
public static void main(String[] args) throws InterruptedException {
final StopWatch sw = new StopWatch("计时器测试");
sw.start("任务一");
Thread.sleep(1000);
sw.stop();
sw.start("任务二");
Thread.sleep(1000);
sw.stop();
//优雅的展示本次计时器的所有任务详情
System.out.println(sw.prettyPrint());
//简约的显示该计时器执行总耗时
System.out.println(sw.shortSummary());
//总任务数
System.out.println(sw.getId() + "任务数:" + sw.getTaskCount());
//获取该计时器执行总耗时的毫秒值
System.out.println(sw.getId() + "总耗时(ms):" + sw.getTotalTimeMillis());
}
输出结果：
StopWatch '计时器测试': running time = 1999923000 ns
---------------------------------------------
ns % Task name
---------------------------------------------
999864500 050% 任务一
1000058500 050% 任务二
StopWatch '计时器测试': running time = 1999923000 ns
计时器测试任务数:2
计时器测试总耗时(ms):1999
使用StopWatch 类自带的 prettyPrint() 方法类格式化我们的输出，其中不仅有总用时，还有每个任务分别的占用时间和占用时间的百分比；
但是注意，一个StopWatch实例一次只能开启一个task任务，不能同时start多个task，并且在该task未stop之前不能start一个新的task，必须在该task stop之后才能开启新的task，若要一次开启多个，需要new不同的StopWatch实例。
API详解
/**
* 构造器
*/
//无参构造，创建一个ID为空的对象
public StopWatch()
//有参构造，创建一个带ID标识符的计时器
public StopWatch(String id)
/**
* API
*/
//获取该StopWatch计时器ID, 计时器ID在构造器指定.
public String getId()
//开启一个未命名任务
public void start()
//开启一个命名任务
public void start(String taskName)
//停止当前任务
public void stop()
//判断此计时器是否有任务正在执行
public boolean isRunning()
//获取当前正在执行的任务名称
public String currentTaskName()
//获取上一个任务执行的纳秒值
public long getLastTaskTimeNanos()
//获取上一个任务执行的毫秒值
public long getLastTaskTimeMillis()
//获取上一个任务名称
public String getLastTaskName()
//设置是否记录每个Task任务信息
public void setKeepTaskList(boolean keepTaskList)
//获取所有任务执行总耗时(以纳秒为单位)
public long getTotalTimeNanos()
//获取所有任务执行总耗时(以毫秒为单位)
public long getTotalTimeMillis()
//获取所有任务执行总耗时(以秒为单位)
public double getTotalTimeSeconds()
//获取该计时器所执行的总任务数
public int getTaskCount()
//获取所有所执行任务的数组
public TaskInfo[] getTaskInfo()
//获取总运行时间的简短描述(以纳秒为单位)
public String shortSummary()
//打印所有已执行任务的 耗时(纳秒)、任务名称、各任务在该计时器所占用时间百分比
public String prettyPrint()
//获取上一个任务的TaskInfo实例
public TaskInfo getLastTaskInfo()
//获取此次任务的名称
public String getTaskName()
//获取此次任务的所用纳秒值
public long getTimeNanos()
//获取此次任务所用毫秒值
public long getTimeMillis()
//获取此任务花费的时间
public double getTimeSeconds()
源码分析
如果还有什么不明白的，接下来看完源码后一切都迎刃而解。
import org.springframework.lang.Nullable;
import java.text.NumberFormat;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* 轻量级计时器，允许计时多个Task任务，公开总运行时间和每个命名任务的运行时间。
*
* 隐藏System.currentTimeMillis();的使用，从而提高了应用程序代码的可读性并减少了计算错误的可能性。
*
* 请注意，此对象并非线程安全的，并且未使用同步修饰。
*
* 从Spring Framework 5.2开始，以纳秒为单位跟踪和报告运行时间。
*/
public class StopWatch {
/**
* 计时器ID
* 当存在多个秒表进行输出时进行区分
*/
private final String id;
/**
* 是否记录任务信息
*/
private boolean keepTaskList = true;
/**
* 保存任务的信息
*/
private final List<TaskInfo> taskList = new LinkedList<>();
/**
* 当前任务开始时间
*/
private long startTimeNanos;
/**
* 当前任务名称
*/
@Nullable
private String currentTaskName;
/**
* 最近一次已完成任务信息
*/
@Nullable
private TaskInfo lastTaskInfo;
/**
* 计时器总任务数
*/
private int taskCount;
/**
* 计时器总耗时
*/
private long totalTimeNanos;
/**
* 构造器
* 新建一个计时器ID为空的计时器实例
* (不启动任何任务)
*/
public StopWatch() {
this("");
}
/**
* 使用给定ID创建一个计时器实例
* 当我们需要从计时器中获得输出并且需要区分它们时，ID很直观。
* (不启动任何任务)
*
* @param id 计时器标识符
*/
public StopWatch(String id) {
this.id = id;
}
/**
* 获取该StopWatch计时器ID, 计时器ID在构造器指定.
*
* @return StopWatch ID (默认为空)
*/
public String getId() {
return this.id;
}
/**
* 设置是否记录任务信息到{@link List}.
* 如果各Task任务或计时器间隔数毫秒导致记录过多时，请将其设置为'false'.
* 否则，{@code TaskInfo}将消耗很多的内存.
* 默认为'true'
*/
public void setKeepTaskList(boolean keepTaskList) {
this.keepTaskList = keepTaskList;
}
/**
* 开启一个未命名的任务
* 如果在此方法之前调用{@link #stop()} 或其他计时方法,则结果未知(默认为0).
*
* @see #start(String)
* @see #stop()
*/
public void start() throws IllegalStateException {
start("");
}
/**
* 开启一个命名任务
* 如果在此方法之前调用{@link #stop()} 或其他计时方法,则结果未知(默认为0).
*
* @param taskName 任务名称
* @see #start()
* @see #stop()
*/
public void start(String taskName) throws IllegalStateException {
//如果任务名称IllegalStateException不为空，代表此时有Task任务正在执行，或存在其他线程内有任务在运行
//抛出异常
//可见相同计时器是不能并发执行的
if (this.currentTaskName != null) {
throw new IllegalStateException("Can't start StopWatch: it's already running");
}
this.currentTaskName = taskName;
//记录当前任务毫秒值
this.startTimeNanos = System.nanoTime();
}
/**
* 停止当前任务.
* 如果该方法不与{@code start()}方法成对出现时，则抛出异常。
*
* @see #start()
* @see #start(String)
*/
public void stop() throws IllegalStateException {
//如果在start()方法之前执行该方法,任务名称=null --> 抛出异常
if (this.currentTaskName == null) {
throw new IllegalStateException("Can't stop StopWatch: it's not running");
}
//计算该此Task任务所耗时
long lastTime = System.nanoTime() - this.startTimeNanos;
//该Task所耗时存入该计时器的总耗时
this.totalTimeNanos += lastTime;
//记录最后一次任务信息到该容器
this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);
if (this.keepTaskList) {
this.taskList.add(this.lastTaskInfo);
}
//任务计数器累加
++this.taskCount;
//清空当前任务
this.currentTaskName = null;
}
/**
* 判断此计时器是否有任务正在执行
*
* @see #currentTaskName()
*/
public boolean isRunning() {
return (this.currentTaskName != null);
}
/**
* 获取当前正在执行的任务名称.
* {@link Nullable}该方法结果可能为NULL或''
*
* @see #isRunning()
*/
@Nullable
public String currentTaskName() {
return this.currentTaskName;
}
/**
* 获取上一个任务执行的纳秒值.
*
* @see #getLastTaskTimeMillis()
*/
public long getLastTaskTimeNanos() throws IllegalStateException {
if (this.lastTaskInfo == null) {
throw new IllegalStateException("No tasks run: can't get last task interval");
}
return this.lastTaskInfo.getTimeNanos();
}
/**
* 获取上一个任务执行的毫秒值.
*
* @see #getLastTaskTimeNanos()
*/
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();
}
/**
* 获取上一个任务名称.
*/
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();
}
/**
* 获取上一个任务的{@link TaskInfo}实例
*/
public TaskInfo getLastTaskInfo() throws IllegalStateException {
if (this.lastTaskInfo == null) {
throw new IllegalStateException("No tasks run: can't get last task info");
}
return this.lastTaskInfo;
}
/**
* 获取所有任务执行总耗时(以纳秒为单位).
*
* @see #getTotalTimeMillis()
* @see #getTotalTimeSeconds()
*/
public long getTotalTimeNanos() {
return this.totalTimeNanos;
}
/**
* 获取所有任务执行总耗时(以毫秒为单位).
*
* @see #getTotalTimeNanos()
* @see #getTotalTimeSeconds()
*/
public long getTotalTimeMillis() {
return nanosToMillis(this.totalTimeNanos);
}
/**
* 获取所有任务执行总耗时(以秒为单位).
*
* @see #getTotalTimeNanos()
* @see #getTotalTimeMillis()
*/
public double getTotalTimeSeconds() {
return nanosToSeconds(this.totalTimeNanos);
}
/**
* 获取该计时器所执行的总任务数.
*/
public int getTaskCount() {
return this.taskCount;
}
/**
* 获取所有所执行任务的数组.
*/
public TaskInfo[] getTaskInfo() {
if (!this.keepTaskList) {
throw new UnsupportedOperationException("Task info is not being kept!");
}
return this.taskList.toArray(new TaskInfo[0]);
}
/**
* 获取总运行时间的简短描述(以纳秒为单位).
*/
public String shortSummary() {
return "StopWatch '" + getId() + "': running time = " + getTotalTimeNanos() + " ns";
}
/**
* 打印所有已执行任务的 耗时(纳秒)、任务名称、各任务在该计时器所占用时间百分比.
*/
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("ns % Task name\n");
sb.append("---------------------------------------------\n");
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMinimumIntegerDigits(9);
nf.setGroupingUsed(false);
NumberFormat pf = NumberFormat.getPercentInstance();
pf.setMinimumIntegerDigits(3);
pf.setGroupingUsed(false);
for (TaskInfo task : getTaskInfo()) {
sb.append(nf.format(task.getTimeNanos())).append(" ");
sb.append(pf.format((double) task.getTimeNanos() / getTotalTimeNanos())).append(" ");
sb.append(task.getTaskName()).append("\n");
}
}
return sb.toString();
}
/**
* Generate an informative string describing all tasks performed
* 重写提String()方法
*/
@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.getTimeNanos()).append(" ns");
long percent = Math.round(100.0 * task.getTimeNanos() / getTotalTimeNanos());
sb.append(" = ").append(percent).append("%");
}
} else {
sb.append("; no task info kept");
}
return sb.toString();
}
/**
* 纳秒转毫秒
*
* @param duration 任务的执行时间
* @return 执行时间的毫秒值
*/
private static long nanosToMillis(long duration) {
return TimeUnit.NANOSECONDS.toMillis(duration);
}
/**
* 纳秒转秒
*
* @param duration 任务的执行时间
* @return 执行时间的秒值
*/
private static double nanosToSeconds(long duration) {
return duration / 1_000_000_000.0;
}
/**
* 内部类，用于记录每个Task任务的信息.
*/
public static final class TaskInfo {
/**
* 任务名称
*/
private final String taskName;
/**
* 任务所耗纳秒值
*/
private final long timeNanos;
/**
* 构造器
*
* @param taskName 任务名称
* @param timeNanos 任务所耗纳秒值
*/
TaskInfo(String taskName, long timeNanos) {
this.taskName = taskName;
this.timeNanos = timeNanos;
}
/**
* 获取此次任务的名称.
*/
public String getTaskName() {
return this.taskName;
}
/**
* 获取此次任务的所用纳秒值.
*
* @see #getTimeMillis()
* @see #getTimeSeconds()
*/
public long getTimeNanos() {
return this.timeNanos;
}
/**
* 获取此次任务所用毫秒值.
*
* @see #getTimeNanos()
* @see #getTimeSeconds()
*/
public long getTimeMillis() {
return nanosToMillis(this.timeNanos);
}
/**
* 获取此任务花费的时间(以秒为单位)。
*
* @see #getTimeMillis()
* @see #getTimeNanos()
*/
public double getTimeSeconds() {
return nanosToSeconds(this.timeNanos);
}
}
}
你会发现该类使用LinkedList实现了一个叫做taskList的队列，然后每一次调用stop()方法停止任务的时候除了计算本地任务执行的时间，还会构建一个描述当前任务的TaskInfo对象，并把它放入taskList队列中。
当执行prettyPrint()方法的时候，就从taskList队列中取出任务实例，然后做一些格式化的操作。