一、前言
代码耗时统计在日常开发中算是一个十分常见的需求,特别是在需要找出代码性能瓶颈时。
可能也是受限于 Java 的语言特性,总觉得代码写起来不够优雅,大量的耗时统计代码,干扰了业务逻辑。特别是开发功能的时候,有个感受就是刚刚开发完代码很清爽优雅,结果加了一大堆辅助代码后,整个代码就变得臃肿了,自己看着都挺难受。因此总想着能不能把这块写的更优雅一点,今天本文就尝试探讨下“代码耗时统计”这一块。
在开始正文前,先说下前提,“代码耗时统计”的并不是某个方法的耗时,而是任意代码段之间的耗时。这个代码段,可能是一个方法中的几行代码,也有可能是从这个方法的某一行到另一个被调用方法的某一行,因此通过 AOP 方式是不能实现这个需求的。
二、常规方法
2.1 时间差统计
这种方式是最简单的方法,记录下开始时间,再记录下结束时间,计算时间差即可。
1 2 3 4 5 6 7 8 9 10 11 12 13
| 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)); } }
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
| public class TimeUtils {
public static long nowMs() { return System.currentTimeMillis(); }
public static long diffMs(long startMillis) { return diffMs(startMillis, nowMs()); } }
|
这种方式的优点是实现简单,利于理解;缺点就是对代码的侵入性较大,看着很傻瓜,不优雅。
2.2 StopWatch
第二种方式是参考 StopWatch
,StopWatch 通常被用作统计代码耗时,各个框架和 Common 包都有自己的实现。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
| 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())); } }
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
| public class TraceWatch { private long startMs;
@Nullable private String currentTaskName;
@Getter private final Map<String, List<TaskInfo>> taskMap = new HashMap<>();
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; }
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
类,这个方法提供了两种耗时统计的方法:
- 通过调用
Start(name)
和 Stop()
方法,进行耗时统计。
- 通过调用
Record(name, timeCost)
,方法,直接记录耗时信息。
这种方式本质上和“时间差统计”是一致的,只是抽取了一层,稍微优雅了一点。
注:你可以根据自己的业务需要,自行修改 TraceWatch 内部的数据结构,我这里简单起见,内部的数据结构只是随便举了个例子。
三、高级方法
第二节提到的两种方法,用大白话来说都是“直来直去”的感觉,我们还可以尝试把代码写的更简便一点。
3.1 Function
在 jdk 1.8 中,引入了 java.util.function
包,通过该类提供的接口,能够实现在指定代码段的上下文执行额外代码的功能。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
| 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())); } }
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
| 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 的方法,实现了耗时统计的功能。
3.2 AutoCloseable
除了利用 Function 的特性,我们还可以使用 jdk 1.7 的 AutoCloseable
特性。说 AutoCloseable 可能有同学没听过,但是给大家展示下以下代码,就会立刻明白是什么东西了。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
| 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; }
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
类进行改造:
-
实现 AutoCloseable
接口,实现 close()
接口:
1 2 3 4
| @Override public void close() { this.stop(); }
|
-
修改 start()
方法,使其支持链式调用:
1 2 3 4 5 6 7 8 9
| 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; }
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
| 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())); } }
|
四、总结
本文列举了四种统计代码耗时的方法:
- 时间差统计
- StopWatch
- Function
- AutoCloseable
列举的方案是我目前能想到的方案。当然可能有更加优雅的方案,希望有相关经验的同学能在评论区一起交流下~