如何优雅的统计代码耗时

已于 2022-04-06 15:02:15 修改
阅读量180 收藏
点赞数
分类专栏： 常用开发工具之Java 文章标签： java
于 2021-10-14 12:43:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36259143/article/details/120761692
版权

原文链接：https://blog.csdn.net/yuanlaijike/article/details/109257825

一、前言

代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。

可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。

在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。这个代码段，可能是一个方法中的几行代码，也有可能是从这个方法的某一行到另一个被调用方法的某一行，因此通过 AOP 方式是不能实现这个需求的。

二、常规方法

1、时间差统计

这种方式是最简单的方法，记录下开始时间，再记录下结束时间，计算时间差即可。

public class TimeDiffTest {
    public static void main(String[] args) throws InterruptedException {
        final long startMs = TimeUtils.nowMs();
        TimeUnit.SECONDS.sleep(5); // 模拟业务代码
        System.out.println("timeCost: " + TimeUtils.diffMs(startMs));
    }
}
// output: timeCost: 5005

public class TimeUtils {
    /**
     * @return 当前毫秒数
     */
    public static long nowMs() {
        return System.currentTimeMillis();
    }

    /**
     * 当前毫秒与起始毫秒差
     * @param startMillis 开始纳秒数
     * @return 时间差
     */
    public static long diffMs(long startMillis) {
        return diffMs(startMillis, nowMs());
    }
}

这种方式的优点是实现简单，利于理解；缺点就是对代码的侵入性较大，看着很傻瓜，不优雅。

2、StopWatch

计时器工具 StopWatch（CSDN博客：陈皮的JavaLib的博客）https://javalib.blog.csdn.net/article/details/123932821

第二种方式是参考 StopWatch ，StopWatch 通常被用作统计代码耗时，各个框架和 Common 包都有自己的实现。

Spring StopWatch 有以下几个常用方法：

  • StopWatch()：构造一个计时器
  • StopWatch(String id)：构造一个指定 id 的计时器
  • start()：创建一个名为空字符串的计时任务，开始计时
  • start(String taskName)：创建一个指定名称计时任务，开始计时
  • stop()：结束当前任务的计时
  • getTotalTimeNanos()：获取全部任务的执行时间，单位纳秒
  • getTotalTimeMillis()：获取全部任务的执行时间，单位毫秒
  • shortSummary()：获取简单的统计信息
  • prettyPrint()：以友好方式输出总统计时间，以及各个阶段任务的执行时间
  • setKeepTaskList(boolean keepTaskList)：是否在内部的列表中存储每一个任务
public class TraceWatchTest {
    public static void main(String[] args) throws InterruptedException {
        TraceWatch traceWatch = new TraceWatch();

        traceWatch.start("function1");
        TimeUnit.SECONDS.sleep(1); // 模拟业务代码
        traceWatch.stop();

        traceWatch.start("function2");
        TimeUnit.SECONDS.sleep(1); // 模拟业务代码
        traceWatch.stop();

        traceWatch.record("function1", 1); // 直接记录耗时

        System.out.println(JSON.toJSONString(traceWatch.getTaskMap()));
    }
}

/* output: 
{"function2":[{"data":1000,"taskName":"function2"}],"function1":[{"data":1000,"taskName":"function1"},{"data":1,"taskName":"function1"}]}
*/

public class TraceWatch {
    /** Start time of the current task. */
    private long startMs;

    /** Name of the current task. */
    @Nullable
    private String currentTaskName;

    @Getter
    private final Map<String, List<TaskInfo>> taskMap = new HashMap<>();

    /**
     * 开始时间差类型指标记录，如果需要终止，请调用 {@link #stop()}
     *
     * @param taskName 指标名
     */
    public void start(String taskName) throws IllegalStateException {
        if (this.currentTaskName != null) {
            throw new IllegalStateException("Can't start TraceWatch: it's already running");
        }
        this.currentTaskName = taskName;
        this.startMs = TimeUtils.nowMs();
    }

    /**
     * 终止时间差类型指标记录，调用前请确保已经调用
     */
    public void stop() throws IllegalStateException {
        if (this.currentTaskName == null) {
            throw new IllegalStateException("Can't stop TraceWatch: it's not running");
        }
        long lastTime = TimeUtils.nowMs() - this.startMs;

        TaskInfo info = new TaskInfo(this.currentTaskName, lastTime);

        this.taskMap.computeIfAbsent(this.currentTaskName, e -> new LinkedList<>()).add(info);

        this.currentTaskName = null;
    }

    /**
     * 直接记录指标数据，不局限于时间差类型
     *  @param taskName 指标名
     * @param data 指标数据
     */
    public void record(String taskName, Object data) {
        TaskInfo info = new TaskInfo(taskName, data);

        this.taskMap.computeIfAbsent(taskName, e -> new LinkedList<>()).add(info);
    }

    @Getter
    @AllArgsConstructor
    public static final class TaskInfo {
        private final String taskName;

        private final Object data;
    }
}

我是仿照 org.springframework.util.StopWatch 的实现，写了 TraceWatch 类，这个方法提供了两种耗时统计的方法：

  1. 通过调用 Start(name) 和 Stop() 方法，进行耗时统计。
  2. 通过调用 Record(name, timeCost)，方法，直接记录耗时信息。

这种方式本质上和“时间差统计”是一致的，只是抽取了一层，稍微优雅了一点。

注：你可以根据自己的业务需要，自行修改 TraceWatch 内部的数据结构，我这里简单起见，内部的数据结构只是随便举了个例子。

三、高级方法

第二节提到的两种方法，用大白话来说都是“直来直去”的感觉，我们还可以尝试把代码写的更简便一点。

1、Function

在 jdk 1.8 中，引入了 java.util.function 包，通过该类提供的接口，能够实现在指定代码段的上下文执行额外代码的功能。

public class TraceHolderTest {
    public static void main(String[] args) {
        TraceWatch traceWatch = new TraceWatch();

        TraceHolder.run(traceWatch, "function1", i -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        String result = TraceHolder.run(traceWatch, "function2", () -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
                return "YES";
            } catch (InterruptedException e) {
                e.printStackTrace();
                return "NO";
            }
        });

        TraceHolder.run(traceWatch, "function1", i -> {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(JSON.toJSONString(traceWatch.getTaskMap()));
    }
}

/* output: 
{"function2":[{"data":1004,"taskName":"function2"}],"function1":[{"data":1001,"taskName":"function1"},{"data":1002,"taskName":"function1"}]}
*/

public class TraceHolder {
    /**
     * 有返回值调用
     */
    public static <T> T run(TraceWatch traceWatch, String taskName, Supplier<T> supplier) {
        try {
            traceWatch.start(taskName);

            return supplier.get();
        } finally {
            traceWatch.stop();
        }
    }

    /**
     * 无返回值调用
     */
    public static void run(TraceWatch traceWatch, String taskName, IntConsumer function) {
        try {
            traceWatch.start(taskName);

            function.accept(0);
        } finally {
            traceWatch.stop();
        }
    }
}

这里我利用了 Supplier 和 IntConsumer 接口，对外提供了有返回值和无返回值得调用，在 TraceHolder 类中，在核心代码块的前后，分别调用了前文的 TraceWatch 的方法，实现了耗时统计的功能。

2、AutoCloseable

除了利用 Function 的特性，我们还可以使用 jdk 1.7 的 AutoCloseable 特性。说 AutoCloseable 可能有同学没听过，但是给大家展示下以下代码，就会立刻明白是什么东西了。

// 未使用 AutoCloseable
public static String readFirstLingFromFile(String path) throws IOException {
    BufferedReader br = null;
    try {
        br = new BufferedReader(new FileReader(path));
        return br.readLine();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (br != null) {
            br.close();
        }
    }
    return null;
}

// 使用 AutoCloseable
public static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

在 try 后方可以加载一个实现了 AutoCloseable 接口的对象，该对象作用于整个 try 语句块中，并且在执行完毕后回调 AutoCloseable#close() 方法。

让我们对 TraceWatch 类进行改造：

1、实现 AutoCloseable 接口，实现 close() 接口：

@Override
public void close() {
    this.stop();
}

2、修改 start() 方法，使其支持链式调用：

public TraceWatch start(String taskName) throws IllegalStateException {
    if (this.currentTaskName != null) {
        throw new IllegalStateException("Can't start TraceWatch: it's already running");
    }
    this.currentTaskName = taskName;
    this.startMs = TimeUtils.nowMs();
    return this;
}

public class AutoCloseableTest {
    public static void main(String[] args) {
        TraceWatch traceWatch = new TraceWatch();

        try(TraceWatch ignored = traceWatch.start("function1")) {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try(TraceWatch ignored = traceWatch.start("function2")) {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        try(TraceWatch ignored = traceWatch.start("function1")) {
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟业务代码
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println(JSON.toJSONString(traceWatch.getTaskMap()));
    }
}

/* output: 
{"function2":[{"data":1001,"taskName":"function2"}],"function1":[{"data":1002,"taskName":"function1"},{"data":1002,"taskName":"function1"}]}
*/

四、总结

本文列举了四种统计代码耗时的方法：

  • 时间差统计
  • StopWatch
  • Function
  • AutoCloseable

列举的方案是我目前能想到的方案。当然可能有更加优雅的方案，希望有相关经验的同学能在评论区一起交流下~

如何优雅的统计Python代码耗时？Python统计代码耗时的几种方法
吾非同
03-30 3246
本文实例讲述了Python中统计代码片段、函数运行耗时的几种方法，分享给大家，仅供参考。时间戳相减在代码执行前后各记录一个时间点，两个时间戳相减即程序运行耗时。获取时间戳time.time...
几种代码耗时统计方法，帮你找出程序慢在哪里
m0_71777195的博客
08-30 1387
代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。......
如何知道代码跑得多慢？
woaimx_1314的博客
05-22 211
它的内部实现原理并不难。测算时间，就是记录(用变量保存)开始时间，并在结束时计算一下时间差。进度功能，则是记录上一次的输出时间和进度，下次输出时作对比。暂停功能，则是用两个变量分别记录工作和等待的耗时累加值。至于如何知道自己是不是“最外层”，则是用一个static变量来保存当前的层数。如果是0就是最外层。它的每一处实现，都是平淡无奇。借用棋类的话，就是“通盘无妙手”。关键是实用。
代码时间分析
Ronnie_Hu的博客
07-15 1084
代码时间分析（Code Timing Analysis）是为了保证代码在规定的时间内都能执行完，常用的分析方法有软件仿真和波形测试，软件仿真指的就是加断点调试，在这里不做介绍，以下主要对波形测试进行说明。
如何分析程序的时间消耗
前路漫漫的博客
09-23 2295
总结一些常用的方法，思考如何分析一个程序的时间消耗。 1.  Trace Log  这个是大家最常用，也是最简单和有效地方法。通常是在函数的开始和结束的位置加入Log, 最后通过Log记录时间统计函数的时间消耗。 有时嫌2次log太麻烦，我们可以通过RAII进行封装： class CTimeCostDebug { public:  CTimeCostDebug(L
perf record对C++程序耗时进行分析
fangfanglovezhou的博客
05-01 3696
本节将介绍如何使用perf工具的perf record对C++代码进行性能分析，一切操作都是在ubuntu 20下进行。
基于IDEA调试模式与StopWatch工具类如何优雅实现Java代码执行时间检测统计博文的代码工程
最新发布
07-01
作为程序员在我们的日常编码过程中经常需要统计一段代码或者一个方法的执行时间，尤其是当以一个接口的执行响应时间比较长需要优化的时候，我们就需要统计接口实现方法中的那些代码片段执行比较耗时，然后再针对耗时...
五分钟教你如何优雅的统计代码耗时，让你知道你的程序到底慢在哪！
02-19 296
一、前言 代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。 可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。 在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。这个代码段，可能.
代码剖析（Code profiling） 代码 内存、耗时、调用等情况
实践出真理
02-23 1480
和gprof类似的分析工具，但它对程序的运行观察更是入微，能给我们提供更多的信息。和 gprof不同，它不需要在编译源代码时附加特殊选项，但加上调试选项是推荐的。Callgrind收集程序运行时的一些数据，建立函数调用关系图， 还可以有选择地进行cache模拟。在运行结束时，它会把分析数据写入一个文件。callgrind_annotate可以把这个文件的内容转化成可读的 形式。valgrind不是linux的原生工具，需要自行安装。
Java计算程序代码执行时间的方法小结
08-28
主要介绍了Java计算程序代码执行时间的方法,结合实例形式总结分析了java采用毫秒数及纳秒数计算程序运行时间的相关操作技巧,需要的朋友可以参考下
统计代码执行时间
guo_lei_lamant的博客
03-21 624
需要用到 time.h //time.cpp #include &lt;time.h&gt; #include &lt;iostream&gt; int main() { clock_t t; long n = 1500 * 1500 ; std::cout &lt;&lt; "Begin clock" &lt;&lt; std::endl; //第一次调用...
这样统计代码执行耗时，才足够优雅！
程序员高级码农的博客
02-27 590
代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。
python 代码执行时间分析与优化
weixin_42480337的博客
02-10 463
具体查看教程：https://blog.csdn.net/weixin_42245157/article/details/125415104。5、有各种条件判定的时候，先把最可能出现的放前面，直接去执行；3、如果采用pandas计算的时候，多次查找各种值，可以暂时开一个变量进行存取操作；6、各种if 的时候，把最不可能的条件放前面，这样到短路法则就省去后面的执行与判定；8、推荐一个第三方分析执行的工具，kernprof，执行的方式。1、特别执行高频交易的时候，需要多线程多进程的工作。
分享几种优雅统计代码耗时的方式，快速查明程序慢在哪里！
罗翔
08-30 707
一、前言 代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。 可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。 在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。这个代码段，可能是
Java：计算代码耗时的5种方法
weixin_44663622的博客
04-30 1356
Java：计算代码耗时的5种方法 ps:本文来自“Java 笔记虾” 公众号，本人转载 1、使用System.currentTimeMillis()函数 代码如下： long start = System.currentTimeMillis(); // some code long finish = System.currentTimeMillis(); long timeElapsed = finish - start; 2、使用System.nanoTime()函数 代码如下： long sta
JAVA方法执行耗时分析工具：Arthas（阿尔萨斯）
spb229443329的专栏
03-02 1885
Arthas 是一款线上监控诊断产品，通过全局视角实时查看应用 load、内存、gc、线程的状态信息，并能在不修改应用代码的情况下，对业务问题进行诊断，包括查看方法调用的出入参、异常，监测方法执行耗时，类加载信息等，大大提升线上问题排查效率。
Java统计代码执行时间统计代码耗时
万事俱备，就差一个程序员了
08-12 2311
import com.google.common.base.Stopwatch; import java.util.concurrent.TimeUnit; public class TimeIntervalTest { public static void main(String[] args) throws InterruptedException { // 创建并启动计时器 Stopwatch stopwatch = Stopwatch.createStarted(); // 执行时间（1s） Thr
打印java代码执行时间
weixin_43526092的博客
03-22 7835
// 代码运行开始时间 Long startTime = System.currentTimeMillis(); // 代码运行结束时间 Long endTime = System.currentTimeMillis(); // 计算并打印耗时 Long tempTime = (endTime - startTime); log.info("开支单列表查询花费时间："+ (((tempTime/86400000)>0)?((tempTime/86400000)+"d"):
高效统计代码行数的小工具使用指南
手动统计需要开发者逐个文件进行计数，这种方法不仅耗时而且容易出错。使用命令行工具，如 wc（word count）命令，虽然能够快速统计文件中的行数，但无法区分代码行和注释行，也无法识别代码库中不同语言的代码行数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值