扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 后端开发 > Python >Spring计时器stopwatch使用详解
  • 345

0
分享到

Spring计时器stopwatch使用详解

2024-04-02 19:04:59 345人浏览 薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

 StopWatch是位于org.springframework.util包下的一个工具类，通过它可方便的对程序部分代码进行计时(ms级别)，适用于同步单线程代码块。 正

 StopWatch是位于org.springframework.util包下的一个工具类，通过它可方便的对程序部分代码进行计时(ms级别)，适用于同步单线程代码块。
正常情况下，我们如果需要看某段代码的执行耗时，会通过如下的方式进行查看：


public static void main(String[] args) throws InterruptedException {
     StopWatchTest.test0();
//        StopWatchTest.test1();
}

public static void test0() throws InterruptedException {
     long start = System.currentTimeMillis();
     // do something
     Thread.sleep(100);
    long end = System.currentTimeMillis();
    long start2 = System.currentTimeMillis();
    // do something
    Thread.sleep(200);
    long end2 = System.currentTimeMillis();
    System.out.println("某某1执行耗时:" + (end - start));
    System.out.println("某某2执行耗时:" + (end2 - start2));
}


运行结果：
某某1执行耗时:105
某某2执行耗时:203

    该种方法通过获取执行完成时间与执行开始时间的差值得到程序的执行时间，简单直接有效，但想必写多了也是比较烦人的，尤其是碰到不可描述的代码时，会更加的让人忍不住多写几个bug聊表敬意，而且该结果也不够直观，此时会想是否有一个工具类，提供了这些方法，或者自己写个工具类，刚好可以满足这种场景，并且把结果更加直观的展现出来。
首先我们的需求如下：

  1. 记录开始时间点
  2. 记录结束时间点
  3. 输出执行时间及各个时间段的占比

 根据该需求，我们可直接使用org.springframework.util包下的一个工具类StopWatch,通过该工具类，我们对上述代码做如下改造：


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，查看程序执行时间。
运行代码及结果：


System.out.println("sw.shortSummary()~~~~~~~~~~~~~~~~~");
System.out.println(sw.shortSummary());
System.out.println("sw.getTotalTimeMillis()~~~~~~~~~~~~~~~~~");
System.out.println(sw.getTotalTimeMillis());
运行结果
sw.shortSummary()~~~~~~~~~~~~~~~~~
StopWatch 'test': running time (millis) = 308
sw.getTotalTimeMillis()~~~~~~~~~~~~~~~~~
308

 其实以上内容在该工具类中实现也极其简单，通过start与stop方法分别记录开始时间与结束时间，其中在记录结束时间时，会维护一个链表类型的tasklist属性，从而使该类可记录多个任务，最后的输出也仅仅是对之前记录的信息做了一个统一的归纳输出，从而使结果更加直观的展示出来。
StopWatch优缺点：
优点：

  1. spring自带工具类，可直接使用
  2. 代码实现简单，使用更简单
  3. 统一归纳，展示每项任务耗时与占用总时间的百分比，展示结果直观性能消耗相对较小，并且最大程度的保证了start与stop之间的时间记录的准确性
  4. 可在start时直接指定任务名字，从而更加直观的显示记录结果

缺点：

  1. 一个StopWatch实例一次只能开启一个task，不能同时start多个task，并且在该task未stop之前不能start一个新的task，必须在该task stop之后才能开启新的task，若要一次开启多个，需要new不同的StopWatch实例
  2. 代码侵入式使用，需要改动多处代码

spring中StopWatch源码实现如下：


import java.text.NumberFORMat;
import java.util.LinkedList;
import java.util.List;

public class StopWatch {
    private final String id;
    private boolean keepTaskList = true;
    private final List<TaskInfo> taskList = new LinkedList();
    private long startTimeMillis;
    private boolean running;
    private String currentTaskName;
    private StopWatch.TaskInfo lastTaskInfo;
    private int taskCount;
    private long totalTimeMillis;

    public StopWatch() {
        this.id = "";
    }

    public StopWatch(String id) {
        this.id = id;
    }

    public void seTKEepTaskList(boolean keepTaskList) {
        this.keepTaskList = keepTaskList;
    }

    public void start() throws IllegalStateException {
        this.start("");
    }

    public void start(String taskName) throws IllegalStateException {
        if (this.running) {
            throw new IllegalStateException("Can't start StopWatch: it's already running");
        } else {
            this.startTimeMillis = System.currentTimeMillis();
            this.running = true;
            this.currentTaskName = taskName;
        }
    }

    public void stop() throws IllegalStateException {
        if (!this.running) {
            throw new IllegalStateException("Can't stop StopWatch: it's not running");
        } else {
            long lastTime = System.currentTimeMillis() - this.startTimeMillis;
            this.totalTimeMillis += lastTime;
            this.lastTaskInfo = new StopWatch.TaskInfo(this.currentTaskName, lastTime);
            if (this.keepTaskList) {
                this.taskList.add(this.lastTaskInfo);
            }

            ++this.taskCount;
            this.running = false;
            this.currentTaskName = null;
        }
    }

    public boolean isRunning() {
        return this.running;
    }

    public long getLastTaskTimeMillis() throws IllegalStateException {
        if (this.lastTaskInfo == null) {
            throw new IllegalStateException("No tasks run: can't get last task interval");
        } else {
            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");
        } else {
            return this.lastTaskInfo.getTaskName();
        }
    }

    public StopWatch.TaskInfo getLastTaskInfo() throws IllegalStateException {
        if (this.lastTaskInfo == null) {
            throw new IllegalStateException("No tasks run: can't get last task info");
        } else {
            return this.lastTaskInfo;
        }
    }

    public long getTotalTimeMillis() {
        return this.totalTimeMillis;
    }

    public double getTotalTimeSeconds() {
        return (double) this.totalTimeMillis / 1000.0D;
    }

    public int getTaskCount() {
        return this.taskCount;
    }

    public StopWatch.TaskInfo[] getTaskInfo() {
        if (!this.keepTaskList) {
            throw new UnsupportedOperationException("Task info is not being kept!");
        } else {
            return (StopWatch.TaskInfo[]) this.taskList.toArray(new StopWatch.TaskInfo[this.taskList.size()]);
        }
    }

    public String shortSummary() {
        return "StopWatch '" + this.id + "': running time (millis) = " + this.getTotalTimeMillis();
    }

    public String prettyPrint() {
        StringBuilder sb = new StringBuilder(this.shortSummary());
        sb.append('\n');
        if (!this.keepTaskList) {
            sb.append("No task info kept");
        } else {
            sb.append("-----------------------------------------\n");
            sb.append("ms     %     Task name\n");
            sb.append("-----------------------------------------\n");
            NumberFormat nf = NumberFormat.getNumberInstance();
            nf.setMinimumIntegerDigits(5);
            nf.setGroupingUsed(false);
            NumberFormat pf = NumberFormat.getPercentInstance();
            pf.setMinimumIntegerDigits(3);
            pf.setGroupingUsed(false);
            StopWatch.TaskInfo[] var7;
            int var6 = (var7 = this.getTaskInfo()).length;

            for (int var5 = 0; var5 < var6; ++var5) {
                StopWatch.TaskInfo task = var7[var5];
                sb.append(nf.format(task.getTimeMillis())).append("  ");
                sb.append(pf.format(task.getTimeSeconds() / this.getTotalTimeSeconds())).append("  ");
                sb.append(task.getTaskName()).append("\n");
            }
        }

        return sb.toString();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder(this.shortSummary());
        if (this.keepTaskList) {
            StopWatch.TaskInfo[] var5;
            int var4 = (var5 = this.getTaskInfo()).length;

            for (int var3 = 0; var3 < var4; ++var3) {
                StopWatch.TaskInfo task = var5[var3];
                sb.append("; [").append(task.getTaskName()).append("] took ").append(task.getTimeMillis());
                long percent = Math.round(100.0D * task.getTimeSeconds() / this.getTotalTimeSeconds());
                sb.append(" = ").append(percent).append("%");
            }
        } else {
            sb.append("; no task info kept");
        }

        return sb.toString();
    }

    public static final class TaskInfo {
        private final String taskName;
        private final long timeMillis;

        TaskInfo(String taskName, long timeMillis) {
            this.taskName = taskName;
            this.timeMillis = timeMillis;
        }

        public String getTaskName() {
            return this.taskName;
        }

        public long getTimeMillis() {
            return this.timeMillis;
        }

        public double getTimeSeconds() {
            return (double) this.timeMillis / 1000.0D;
        }
    }

}

到此这篇关于Spring计时器stopwatch使用详解的文章就介绍到这了,更多相关Spring计时器stopwatch内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: Spring计时器stopwatch使用详解

本文链接: https://lsjlt.com/news/132431.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

猜你喜欢
  • Spring计时器stopwatch使用详解
     StopWatch是位于org.springframework.util包下的一个工具类，通过它可方便的对程序部分代码进行计时(ms级别)，适用于同步单线程代码块。 正...
    99+
    2024-04-02
  • Java计时新姿势StopWatch的使用方法详解
    目录一、背景二、spring 用法2.1 初遇2.2 源码2.3 注意事项三、apache 用法四、java 中使用StopWatch来计算时间差五、最后一、背景 有时我们在做开发的...
    99+
    2024-04-02
  • Java Stopwatch类,性能与时间计时器案例详解
    　　在研究性能的时候，完全可以使用Stopwatch计时器计算一项技术的效率。但是有时想知道某想技术的性能的时候，又常常想不起可以运用Stopwatch这个东西，太可悲了。 属性： ...
    99+
    2024-04-02
  • Java计时器工具StopWatch的具体使用
    目录前言Spring StopWatch实践例子源码分析lang3 StopWatch总结前言 平常，我们想要统计某一段代码块，或某一个方法的执行时间，最简单的是采用如下的方式。 ...
    99+
    2024-04-02
  • C#中使用Stopwatch计时器实现暂停计时继续计时功能
    最近程序上用到了计时功能，对某个模块进行计时，暂停的时候模块也需要暂停，启动的时候计时继续 用到了Stopwatch Stopwatch的命名空间是using System.Diag...
    99+
    2024-04-02
  • Spring Boot源码实现StopWatch优雅统计耗时
    目录引言StopWatch使用使用Beyond compare比较引言 昨天，一位球友问我能不能给他解释一下 @SpringBootApplication 注解是什么意思，还有 Sp...
    99+
    2024-04-02
  • Qt计时器使用方法详解
    本文实例为大家分享了Qt计时器的使用方法，供大家参考，具体内容如下 计时器 在我们的日常设计程序中，经常需要固定时间段来刷新界面或者处理一些事务，这个时候计时器就很重要。 比如说在用...
    99+
    2022-11-13
    Qt 计时器
  • 用StopWatch优雅替代currentTimeMillis计算程序执行耗时
    需求 有时需要记录程序执行时间，最简单就是打印当前时间与执行完时间的差值，缺点是： 执行大量测试的话就很麻烦 不直观 如果想对执行的时间做进一步控制，则需要...
    99+
    2024-04-02
  • Node.js中使用计时器定时执行函数详解
    如果你熟悉客户端JavaScript编程，你可能使用过setTimeout和setInterval函数，这两个函数允许延时一段时间再运行函数。比如下面的代码， 一旦被加载到Web页面，1秒后会在页面文档后追...
    99+
    2022-06-04
    计时器 详解 函数
  • Vue计时器的用法详解
    本文实例为大家分享了Vue实现计时器的具体代码，供大家参考，具体内容如下 功能简介： 1、初始值为0，点击【加】按钮，数字自+1；连续点击【加】，不影响数字+1 2、点击【停】按钮...
    99+
    2024-04-02
  • 详解CocosCreator中几种计时器的使用方法
    一、setTimeOut 3秒后打印abc。只执行一次。 setTimeout(()=>{console.log("abc"); }, 3000); 删除计时器，3秒后不...
    99+
    2024-04-02
  • Spring 定时器使用
    Quartz是一个强大的企业级任务调度框架，Spring中继承并简化了Quartz，下面就看看在Spring中怎样配置Quartz：首先我们来写一个被调度的类： package com.kay.quartz;publicclass Quar...
    99+
    2023-06-03
  • 详解Spring容器的使用流程
    前言 Spring容器的API有 BeanFactory 和 ApplicationContext 两大类，他们都是顶级接口。其中ApplicationContext 是 BeanF...
    99+
    2024-04-02
  • Spring容器-BeanFactory和ApplicationContext使用详解
    目录将BeanFactory和ApplicationContext作为容器使用BeanFactory容器ApplicationContext容器Spring内嵌Web容器的过程将Be...
    99+
    2023-05-17
    Spring BeanFactory ApplicationContext Spring 容器
  • Spring IOC容器使用详细讲解
    目录Spring IOCIOC容器在Spring中的实现ApplicationContext的主要实现类ClassPathXmlApplicationContext获取BeanSpr...
    99+
    2022-12-21
    Spring IOC容器 Spring IOC
  • Spring JDBC的使用详解
    目录JDBC介绍DriverManagerConnectionStatement/PreparedStatementResultSetJDBC访问数据库流程配置数据源使用JDBC操纵...
    99+
    2024-04-02
  • Spring-Retry的使用详解
    目录1 Spring-Retry的简介2 Spring中的应用1 导入maven坐标2 添加被调用类3 添加测试类3 SpringBoot中的应用1 导入maven坐标2 添加一个管...
    99+
    2024-04-02
  • Spring Boot 使用Druid详解
    Druid是Java语言中最好的数据库连接池，并且能够提供强大的监控和扩展功能，下面来说明如何在 SpringBoot 中配置使用Druid。步骤： 在pom.xml中加载依赖 在application.properties中加入数据源配置...
    99+
    2023-05-31
    spring boot druid
  • Spring中WebDataBinder使用详解
    Spring MVC Validator @InitBinder and WebDataBinder;Validator是一个用来我们自定义验证的sping接口,WebDataBinder 绑定你的自定义参数,你直接在你的控制器类中通过@I...
    99+
    2023-05-31
    spring webdatabinder dat
  • Spring Task定时任务的配置和使用详解
    记录下Spring自带的定时任务用法。spring中使用定时任务基于xml配置文件使用定时任务首先配置spring开启定时任务<beans xmlns="http://www.springframework.org/schema/be...
    99+
    2023-05-31
    spring task 用
软考高级职称资格查询
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作