Spring计时器StopWatch使用详解 源码分析

最新推荐文章于 2024-07-23 21:41:01 发布
最新推荐文章于 2024-07-23 21:41:01 发布
阅读量1k 收藏 4
点赞数
分类专栏： Java工具类 文章标签： spring java 开发工具
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37424916/article/details/113702592
版权

前言

    在我们日常开发中有时需要对某一个运算或者方法进行计时，以便我们来观察该运算或方法是否符合我们的预期。

    在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任务，公开总运行时间和每个命名任务的运行时间。
 * <p>
 * 隐藏System.currentTimeMillis();的使用，从而提高了应用程序代码的可读性并减少了计算错误的可能性。
 * <p>
 * 请注意，此对象并非线程安全的，并且未使用同步修饰。
 * <p>
 * 从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<TaskInfo>}.
	 * 如果各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队列中取出任务实例，然后做一些格式化的操作。

秦延金
关注
专栏目录
java之StopWatch源码分析
qq_35006660的博客
10-23 366
计时这个词语在生活中被应用的很普遍，比如，哥们，帮我计时一下在山的那边，海的那边,.........，这好像是一首歌的歌词，坏笑。跑过去需要多长时间?体育竞赛时频繁出现的秒表，发令信号一...
程序监控之StopWatch
HDXxiazai的博客
05-06 384
StopWatch 是 属于 spring core 下的： org.springframework.util.StopWatch StopWatch可以监控多个任务执行，并且可以分别打印出消耗的时间，还提供了线程名自定义的操作。 例子： public static void main(String[] args) throws Exception { // id 可以随意修改，最好使用唯一性的ID 方便日志分析 String id = UUID.rando.
StopWatch：被忽视的任务执行时间监视器
Roker
11-09 2588
背景引入 学习源码的过程中，在springboot启动类的run方法里，看到这样一个对象，遂对其学习了一番。 简介 StopWatch是位于org.springframework.util包下的一个工具类，通过它可方便的对程序部分代码进行计时(ms级别)，适用于同步单线程代码块。用于代码性能监控，不用于实际业务。 允许多个任务的计时，暴露每个命名任务的总运行时间和运行时间。隐藏使用System.currentTimeMillis（），提高应用程序代码的可读性并减少计算错误的可能性。 源码学习 附上中文
Spring Boot学习｜Stopwatch 在 Spring Boot 中的使用
最新发布
weixin_44435110的博客
07-23 1718
`Stopwatch` 是由 Apache Commons Lang 库提供的一种工具类，它允许你测量经过的时间。它可以用来追踪代码中某部分、方法或应用内任何流程的执行时间。它特别适用于性能分析和优化。
Spring的StopWatch
Ginny_2019的博客
01-05 805
StopWatch是位于org.springframework.util包下的一个工具类，通过它可方便的对程序部分代码进行计时(ms级别)，适用于同步单线程代码块。 StopWatch watch = new StopWatch(); watch.start(); watch.stop(); logger.info("案件导入结束，耗时{}", watch.getTotalTimeMilli...
Spring StopWatch
金溪的博客
06-06 290
有时我们在做开发的时候需要记录每个任务执行时间，或者记录一段代码执行时间，最简单的方法就是打印当前时间与执行完时间的差值，然后这样如果执行大量测试的话就很麻烦，并且不直观，如果想对执行的时间做进一步控制，则需要在程序中很多地方修改，而StopWatch类可以做类似任务执行时间控制，也就是封装了一个对开始时间、结束时间记录操作的Java类。 package com.example.stopwat...
Spring 计时器 StopWatch
【欢迎关注公众号：冬瓜白】
04-25 670
有时候要测试某个东东的执行效率，每次都得写一堆 System.currentTimeMillis()，很显然一般会封装一下，避免重复造轮子，可以直接使用 Spring 提供的工具 StopWatch。其实在 Spring Boot 程序启动后都会打印的启动时间，也是基于这个类来的： 2020-04-25 17:09:41.468 INFO 60479 --- [ main] ...
Spring计时器StopWatch
骑个小蜗牛的博客
06-27 8441
StopWatch介绍 StopWatch属性详解 StopWatch方法详解 StopWatch使用示例
Spring计时器StopWatch使用示例
08-19
Spring计时器StopWatch使用示例详解 Stopwatch是Spring框架提供的一个工具类，位于org.springframework.util包下，主要用于对程序部分代码进行计时（ms级别），适用于同步单线程代码块。在开发过程中，我们经常...
spring计时器stopwatch使用详解
08-08
Spring框架中的计时器Stopwatch是一个功能强大且易于使用的工具，用于测量程序代码的执行时间。下面给出了Stopwatch的使用详解。 首先，需要导入Spring的core依赖以及Spring的context依赖。然后，在需要使用计时器...
Guava StopWatch使用
m1234ilu的博客
07-04 739
文章目录 前言 一、StopWatch是什么？ 二、使用步骤 1.引入库 总结 前言 业务中对于一些耗时的操作，经常要打印运行时间，方便后续优化，本文讲解了StopWatch的使用技巧，包括单次使用和循环中的使用。 提示：以下是本篇文章正文内容，下面案例可供参考 一、StopWatch是什么？ StopWatch就是一个计时器，在Apache和Spring的工具类中都有类似的StopWatch，使用上大同小异。功能= endTime - startTime。 二、使用步...
涨姿势：SpringBoot2.x启动全过程源码分析
01-27
《SpringBoot 2.x 启动全过程源码详解》 SpringBoot 2.x 的启动流程是其核心功能的重要组成部分，理解这一过程对于开发者深入掌握框架的运作机制具有重要意义。接下来，我们将逐步剖析SpringApplication对象的run...
.NET/C# 使用Stopwatch测量运行时间
12-23
您可能感兴趣的文章:Spring StopWatch使用实例详解Java计时新姿势StopWatch详解秒表计时器以及STOPWATCH(实例讲解)Javascript实现的StopWatch功能示例C#使用StopWatch获取程序毫秒级执行时间的方法
springframework中的StopWatch的用法
timchen525的专栏
03-21 1847
StopWatch对应的中文名称为秒表，经常我们对一段代码耗时检测的代码如下：long startTime = System.currentTimeMillis(); // 你的业务代码 long endTime = System.currentTimeMillis(); long costTime = endTime -startTime; System.err.println("该段代码耗时：...
用过stopwatch(秒表)观察代码运行的时长吗?
happypX的博客
11-07 215
StopWatch对应的中文名称为秒表，经常我们对一段代码耗时检测的代码如下： 用法展示 @Transactional(rollbackFor = Exception.class) public CollageOrderResponseVO colleageOrder(CollageOrderRequestVO request) { StopWatch stopWatch =...
Spring计时器StopWatch在微服务链路中的使用
qq_39754590的博客
03-26 655
Spring计时器StopWatch在微服务链路中的使用
Spring工具类StopWatch
qq_43409401的博客
07-06 497
Spring工具类StopWatch
Spring 计时工具类 StopWatch
不是好汉
06-05 789
Spring 计时工具类 StopWatch 设计目标 验证程序性能, 记录过程耗时 隐藏System.currentTimeMillis()的使用提升代码可读性 特性 支持多任务计时 非线程安全 主要函数 方法 备注 void start(String) 开始一个任务&开始计时 void stop() 结束一个任务&&记录任务执行时间 String shortSummary() 获取总运行时间的一个简短描述 String prettyPrint(
我们来聊聊spring一个比较有用的工具类：StopWatch
sober_snail的博客
09-20 380
个人公众号，欢迎大家关注： 今天我们来聊聊spring一个比较有用的工具类spring的工具类-StopWatch.https://mp.weixin.qq.com/s/r8bsI4or7dlEA_gGwOEBPg 背景：在公司的开发的过程中，偶然发现了一个很有用的spring的工具类-stopWatch. 之前的我们写代码的时候，如果想知道一个方法的执行耗时时长，代码的方式如下： LongstartTime=System.currentTimeMillis(); //方法体 Long...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值