这 4 种，统计代码执行耗时，才足够优雅！
上一篇： Android 13 正式登场 ！！
目录
01、前言
02、常规方法
03、时间差统计
04、StopWatch
05、高级方法
06、Function
07、AutoCloseable
08、总结
01、前言
02、常规方法
03、时间差统计
04、StopWatch
05、高级方法
06、Function
07、AutoCloseable
08、总结
代码耗时统计在日常开发中算是一个十分常见的需求，特别是在需要找出代码性能瓶颈时。
可能也是受限于 Java 的语言特性，总觉得代码写起来不够优雅，大量的耗时统计代码，干扰了业务逻辑。特别是开发功能的时候，有个感受就是刚刚开发完代码很清爽优雅，结果加了一大堆辅助代码后，整个代码就变得臃肿了，自己看着都挺难受。因此总想着能不能把这块写的更优雅一点，今天本文就尝试探讨下“代码耗时统计”这一块。
在开始正文前，先说下前提，“代码耗时统计”的并不是某个方法的耗时，而是任意代码段之间的耗时。这个代码段，可能是一个方法中的几行代码，也有可能是从这个方法的某一行到另一个被调用方法的某一行，因此 「通过 AOP 方式是不能实现这个需求的」。
二、常规方法2.1 时间差统计
这种方式是最简单的方法，记录下开始时间，再记录下结束时间，计算时间差即可。
publicclassTimeDiffTest{
publicstaticvoidmain(String[] args)throwsInterruptedException {
finallongstartMs = TimeUtils.nowMs;
TimeUnit.SECONDS.sleep( 5); // 模拟业务代码
System.out.println( "timeCost: "+ TimeUtils.diffMs(startMs));
}
}
publicclassTimeUtils{
/**
* @return当前毫秒数
*/
publicstaticlongnowMs{
returnSystem.currentTimeMillis;
}
/**
* 当前毫秒与起始毫秒差
* @paramstartMillis 开始纳秒数
* @return时间差
*/
publicstaticlongdiffMs( longstartMillis) {
returndiffMs(startMillis, nowMs);
}
}
这种方式的优点是实现简单，利于理解；缺点就是对代码的侵入性较大，看着很傻瓜，不优雅。
2.2 StopWatch
第二种方式是参考 StopWatch，StopWatch 通常被用作统计代码耗时，各个框架和 Common 包都有自己的实现。
publicclassTraceWatchTest{
publicstaticvoidmain(String[] args)throwsInterruptedException {
TraceWatch traceWatch = newTraceWatch;
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"}]}
*/
publicclassTraceWatch{
/** Start time of the current task. */
privatelongstartMs;
/** Name of the current task. */
@Nullable
privateString currentTaskName;
@Getter
privatefinalMap<String, List<TaskInfo>> taskMap = newHashMap<>;
/**
* 开始时间差类型指标记录，如果需要终止，请调用 { @link#stop}
*
* @paramtaskName 指标名
*/
publicvoidstart(String taskName)throwsIllegalStateException {
if( this.currentTaskName != null) {
thrownewIllegalStateException( "Can't start TraceWatch: it's already running");
}
this.currentTaskName = taskName;
this.startMs = TimeUtils.nowMs;
}
/**
* 终止时间差类型指标记录，调用前请确保已经调用
*/
publicvoidstopthrowsIllegalStateException {
if( this.currentTaskName == null) {
thrownewIllegalStateException( "Can't stop TraceWatch: it's not running");
}
longlastTime = TimeUtils.nowMs - this.startMs;
TaskInfo info = newTaskInfo( this.currentTaskName, lastTime);
this.taskMap.computeIfAbsent( this.currentTaskName, e -> newLinkedList<>).add(info);
this.currentTaskName = null;
}
/**
* 直接记录指标数据，不局限于时间差类型
* @paramtaskName 指标名
* @paramdata 指标数据
*/
publicvoidrecord(String taskName, Object data){
TaskInfo info = newTaskInfo(taskName, data);
this.taskMap.computeIfAbsent(taskName, e -> newLinkedList<>).add(info);
}
@Getter
@AllArgsConstructor
publicstaticfinalclassTaskInfo{
privatefinalString taskName;
privatefinalObject data;
}
}
我是仿照 org.springframework.util.StopWatch的实现，写了 TraceWatch类，这个方法提供了两种耗时统计的方法：
通过调用 Start(name)和 Stop方法，进行耗时统计。
通过调用 Record(name, timeCost)，方法，直接记录耗时信息。
这种方式本质上和“时间差统计”是一致的，只是抽取了一层，稍微优雅了一点。
❝注：你可以根据自己的业务需要，自行修改 TraceWatch 内部的数据结构，我这里简单起见，内部的数据结构只是随便举了个例子。
❞
注：你可以根据自己的业务需要，自行修改 TraceWatch 内部的数据结构，我这里简单起见，内部的数据结构只是随便举了个例子。
❞
第二节提到的两种方法，用大白话来说都是“直来直去”的感觉，我们还可以尝试把代码写的更简便一点。
3.1 Function
在 jdk 1.8 中，引入了 java.util.function 包，通过该类提供的接口，能够实现在指定代码段的上下文执行额外代码的功能。
publicclassTraceHolderTest{
publicstaticvoidmain(String[] args){
TraceWatch traceWatch = newTraceWatch;
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"}]}
*/
publicclassTraceHolder{
/**
* 有返回值调用
*/
publicstatic<T> T run(TraceWatch traceWatch, String taskName, Supplier<T> supplier){
try{
traceWatch.start(taskName);
returnsupplier.get;
} finally{
traceWatch.stop;
}
}
/**
* 无返回值调用
*/
publicstaticvoidrun(TraceWatch traceWatch, String taskName, IntConsumer function){
try{
traceWatch.start(taskName);
function.accept( 0);
} finally{
traceWatch.stop;
}
}
}
这里我利用了 Supplier和 IntConsumer接口，对外提供了有返回值和无返回值得调用，在 TraceHolder类中，在核心代码块的前后，分别调用了前文的 TraceWatch 的方法，实现了耗时统计的功能。
3.2 AutoCloseable
除了利用 Function 的特性，我们还可以使用 jdk 1.7 的 AutoCloseable特性。说 AutoCloseable 可能有同学没听过，但是给大家展示下以下代码，就会立刻明白是什么东西了。
// 未使用 AutoCloseable
publicstaticString readFirstLingFromFile(String path)throwsIOException {
BufferedReader br = null;
try{
br = newBufferedReader( newFileReader(path));
returnbr.readLine;
} catch(IOException e) {
e.printStackTrace;
} finally{
if(br != null) {
br.close;
}
}
returnnull;
}
// 使用 AutoCloseable
publicstaticString readFirstLineFromFile(String path)throwsIOException {
try(BufferedReader br = newBufferedReader( newFileReader(path))) {
returnbr.readLine;
}
}
在 try后方可以加载一个实现了 AutoCloseable 接口的对象，该对象作用于整个 try 语句块中，并且在执行完毕后回调 AutoCloseable#close方法。
让我们对 TraceWatch类进行改造：
实现 AutoCloseable接口，实现 close接口：
publicvoidclose{
this.stop;
}
修改 start方法，使其支持链式调用：
if( this.currentTaskName != null) {
thrownewIllegalStateException( "Can't start TraceWatch: it's already running");
}
this.currentTaskName = taskName;
this.startMs = TimeUtils.nowMs;
returnthis;
}
publicclassAutoCloseableTest{
publicstaticvoidmain(String[] args){
TraceWatch traceWatch = newTraceWatch;
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
时间差统计
StopWatch
Function
AutoCloseable
列举的方案是我目前能想到的方案。当然可能有更加优雅的方案，希望有相关经验的同学能在评论区一起交流下~
来源：jitwxs.cn
全文完，感谢你的耐心阅读。如果你还想看到我的文章，请一定给本文“在看”、 “点赞”，新文章推送才会第一时间出现在你的微信里。
- END -
热门推荐：
字节面试：说说零拷贝，成功上岸！
为什么 OAuth 里除了 Access Token 之外，还需要 Refresh Token？
Java 8 重构传统设计模式，是真的优雅！
- 用 Arthas 定位 Spring Boot 接口的超时问题，让应用起飞～
- 7行代码让B站崩溃3小时，竟因“一个诡计多端的0”
字节面试：说说零拷贝，成功上岸！
为什么 OAuth 里除了 Access Token 之外，还需要 Refresh Token？
Java 8 重构传统设计模式，是真的优雅！
PS：如果觉得我的分享不错，欢迎大家随手点赞、转发、在看。 返回搜狐，查看更多
责任编辑：