6种快速统计代码执行时间的方法，真香!

本文转载自微信公众号「Java中文社群」，作者磊哥  。转载本文请联系Java中文社群公众号。

创新互联公司是一家专注于成都网站设计、网站建设与策划设计,满城网站建设哪家好?创新互联公司做网站,专注于网站建设十多年,网设计领域的专业建站公司;建站业务涵盖:满城等地区。满城做网站价格咨询:18980820575

我们在日常开发中经常需要测试一些代码的执行时间，但又不想使用向 JMH(Java Microbenchmark Harness，Java 微基准测试套件)这么重的测试框架，所以本文就汇总了一些 Java 中比较常用的执行时间统计方法，总共包含以下 6 种，如下图所示：

方法一：System.currentTimeMillis

此方法为 Java 内置的方法，使用 System#currentTimeMillis 来统计执行的时间(统计单位：毫秒)，示例代码如下：

 
 
 
 
      
  
  
  
  1. public class TimeIntervalTest { 
    2.   
  
  
  
  2.     public static void main(String[] args) throws InterruptedException { 
    3.   
  
  
  
  3.         // 开始时间 
    4.   
  
  
  
  4.         long stime = System.currentTimeMillis(); 
    5.   
  
  
  
  5.         // 执行时间（1s） 
    6.   
  
  
  
  6.         Thread.sleep(1000); 
    7.   
  
  
  
  7.         // 结束时间 
    8.   
  
  
  
  8.         long etime = System.currentTimeMillis(); 
    9.   
  
  
  
  9.         // 计算执行时间 
    10.   
  
  
  
  10.         System.out.printf("执行时长：%d 毫秒.", (etime - stime)); 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12. } 
    13.

以上程序的执行结果为：

执行时长：1000 毫秒.

方法二：System.nanoTime

此方法为 Java 内置的方法，使用 System#nanoTime 来统计执行时间(统计单位：纳秒)，它的执行方法和 System#currentTimeMillis 类似，示例代码如下：

 
 
 
 
      
  
  
  
  1. public class TimeIntervalTest { 
    2.   
  
  
  
  2.     public static void main(String[] args) throws InterruptedException { 
    3.   
  
  
  
  3.         // 开始时间 
    4.   
  
  
  
  4.         long stime = System.nanoTime(); 
    5.   
  
  
  
  5.         // 执行时间（1s） 
    6.   
  
  
  
  6.         Thread.sleep(1000); 
    7.   
  
  
  
  7.         // 结束时间 
    8.   
  
  
  
  8.         long etime = System.nanoTime(); 
    9.   
  
  
  
  9.         // 计算执行时间 
    10.   
  
  
  
  10.         System.out.printf("执行时长：%d 纳秒.", (etime - stime)); 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12. } 
    13.

以上程序的执行结果为：

执行时长：1000769200 纳秒.

小贴士：1 毫秒 = 100 万纳秒。

方法三：new Date

此方法也是 Java 的内置方法，在开始执行前 new Date() 创建一个当前时间对象，在执行结束之后 new Date() 一个当前执行时间，然后再统计两个 Date 的时间间隔，示例代码如下：

 
 
 
 
      
  
  
  
  1. import java.util.Date; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. public class TimeIntervalTest { 
    4.   
  
  
  
  4.     public static void main(String[] args) throws InterruptedException { 
    5.   
  
  
  
  5.         // 开始时间 
    6.   
  
  
  
  6.         Date sdate = new Date(); 
    7.   
  
  
  
  7.         // 执行时间（1s） 
    8.   
  
  
  
  8.         Thread.sleep(1000); 
    9.   
  
  
  
  9.         // 结束时间 
    10.   
  
  
  
  10.         Date edate = new Date(); 
    11.   
  
  
  
  11.         //  统计执行时间（毫秒） 
    12.   
  
  
  
  12.         System.out.printf("执行时长：%d 毫秒." , (edate.getTime() - sdate.getTime()));  
    13.   
  
  
  
  13.     } 
    14.   
  
  
  
  14. } 
    15.

以上程序的执行结果为：

  • 执行时长：1000 毫秒.

方法四：Spring StopWatch

如果我们使用的是 Spring 或 Spring Boot 项目，可以在项目中直接使用 StopWatch 对象来统计代码执行时间，示例代码如下：

 
 
 
 
      
  
  
  
  1. StopWatch stopWatch = new StopWatch(); 
    2.   
  
  
  
  2. // 开始时间 
    3.   
  
  
  
  3. stopWatch.start(); 
    4.   
  
  
  
  4. // 执行时间（1s） 
    5.   
  
  
  
  5. Thread.sleep(1000); 
    6.   
  
  
  
  6. // 结束时间 
    7.   
  
  
  
  7. stopWatch.stop(); 
    8.   
  
  
  
  8. // 统计执行时间（秒） 
    9.   
  
  
  
  9. System.out.printf("执行时长：%d 秒.%n", stopWatch.getTotalTimeSeconds()); // %n 为换行 
    10.   
  
  
  
  10. // 统计执行时间（毫秒） 
    11.   
  
  
  
  11. System.out.printf("执行时长：%d 毫秒.%n", stopWatch.getTotalTimeMillis());  
    12.   
  
  
  
  12. // 统计执行时间（纳秒） 
    13.   
  
  
  
  13. System.out.printf("执行时长：%d 纳秒.%n", stopWatch.getTotalTimeNanos()); 
    14.

以上程序的执行结果为：

执行时长：0.9996313 秒. 执行时长：999 毫秒. 执行时长：999631300 纳秒.

小贴士：Thread#sleep 方法的执行时间稍有偏差，在 1s 左右都是正常的。

方法五：commons-lang3 StopWatch

如果我们使用的是普通项目，那我们可以用 Apache commons-lang3 中的StopWatch 对象来实现时间统计，首先先添加 commons-lang3 的依赖：

 
 
 
 
      
  
  
  
  1.  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.   org.apache.commons 
    4.   
  
  
  
  4.   commons-lang3 
    5.   
  
  
  
  5.   3.10 
    6.   
  
  
  
  6.  
    7.

然后编写时间统计代码：

 
 
 
 
      
  
  
  
  1. import org.apache.commons.lang3.time.StopWatch; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.TimeUnit; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. public class TimeIntervalTest { 
    6.   
  
  
  
  6.     public static void main(String[] args) throws InterruptedException { 
    7.   
  
  
  
  7.         StopWatch stopWatch = new StopWatch(); 
    8.   
  
  
  
  8.         // 开始时间 
    9.   
  
  
  
  9.         stopWatch.start(); 
    10.   
  
  
  
  10.         // 执行时间（1s） 
    11.   
  
  
  
  11.         Thread.sleep(1000); 
    12.   
  
  
  
  12.         // 结束时间 
    13.   
  
  
  
  13.         stopWatch.stop(); 
    14.   
  
  
  
  14.         // 统计执行时间（秒） 
    15.   
  
  
  
  15.         System.out.println("执行时长：" + stopWatch.getTime(TimeUnit.SECONDS) + " 秒."); 
    16.   
  
  
  
  16.         // 统计执行时间（毫秒） 
    17.   
  
  
  
  17.         System.out.println("执行时长：" + stopWatch.getTime(TimeUnit.MILLISECONDS) + " 毫秒."); 
    18.   
  
  
  
  18.         // 统计执行时间（纳秒） 
    19.   
  
  
  
  19.         System.out.println("执行时长：" + stopWatch.getTime(TimeUnit.NANOSECONDS) + " 纳秒."); 
    20.   
  
  
  
  20.     } 
    21.   
  
  
  
  21. } 
    22.

以上程序的执行结果为：

执行时长：1 秒. 执行时长：1000 毫秒.

执行时长：1000555100 纳秒.

方法六：Guava Stopwatch

除了 Apache 的 commons-lang3 外，还有一个常用的 Java 工具包，那就是 Google 的 Guava，Guava 中也包含了 Stopwatch 统计类。首先先添加 Guava 的依赖：

 
 
 
 
      
  
  
  
  1.  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.   com.google.guava 
    4.   
  
  
  
  4.   guava 
    5.   
  
  
  
  5.   29.0-jre 
    6.   
  
  
  
  6.  
    7.

然后编写时间统计代码：

 
 
 
 
      
  
  
  
  1. import com.google.common.base.Stopwatch; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.TimeUnit; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. public class TimeIntervalTest { 
    6.   
  
  
  
  6.     public static void main(String[] args) throws InterruptedException { 
    7.   
  
  
  
  7.         // 创建并启动计时器 
    8.   
  
  
  
  8.         Stopwatch stopwatch = Stopwatch.createStarted(); 
    9.   
  
  
  
  9.         // 执行时间（1s） 
    10.   
  
  
  
  10.         Thread.sleep(1000); 
    11.   
  
  
  
  11.         // 停止计时器 
    12.   
  
  
  
  12.         stopwatch.stop(); 
    13.   
  
  
  
  13.         // 执行时间（单位：秒） 
    14.   
  
  
  
  14.         System.out.printf("执行时长：%d 秒. %n", stopwatch.elapsed().getSeconds()); // %n 为换行 
    15.   
  
  
  
  15.         // 执行时间（单位：毫秒） 
    16.   
  
  
  
  16.         System.out.printf("执行时长：%d 豪秒.", stopwatch.elapsed(TimeUnit.MILLISECONDS)); 
    17.   
  
  
  
  17.     } 
    18.   
  
  
  
  18. } 
    19.

以上程序的执行结果为：

执行时长：1 秒.

执行时长：1000 豪秒.

原理分析本文我们从 Spring 和 Google 的 Guava 源码来分析一下，它们的 StopWatch 对象底层是如何实现的?

1.Spring StopWatch 原理分析

在 Spring 中 StopWatch 的核心源码如下：

 
 
 
 
      
  
  
  
  1. package org.springframework.util; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.text.NumberFormat; 
    4.   
  
  
  
  4. import java.util.LinkedList; 
    5.   
  
  
  
  5. import java.util.List; 
    6.   
  
  
  
  6. import java.util.concurrent.TimeUnit; 
    7.   
  
  
  
  7. import org.springframework.lang.Nullable; 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. public class StopWatch { 
    10.   
  
  
  
  10.     private final String id; 
    11.   
  
  
  
  11.     private boolean keepTaskList; 
    12.   
  
  
  
  12.     private final List taskList; 
    13.   
  
  
  
  13.     private long startTimeNanos; 
    14.   
  
  
  
  14.     @Nullable 
    15.   
  
  
  
  15.     private String currentTaskName; 
    16.   
  
  
  
  16.     @Nullable 
    17.   
  
  
  
  17.     private StopWatch.TaskInfo lastTaskInfo; 
    18.   
  
  
  
  18.     private int taskCount; 
    19.   
  
  
  
  19.     private long totalTimeNanos; 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.     public StopWatch() { 
    22.   
  
  
  
  22.         this(""); 
    23.   
  
  
  
  23.     } 
    24.   
  
  
  
  24.  
    25.   
  
  
  
  25.     public StopWatch(String id) { 
    26.   
  
  
  
  26.         this.keepTaskList = true; 
    27.   
  
  
  
  27.         this.taskList = new LinkedList(); 
    28.   
  
  
  
  28.         this.id = id; 
    29.   
  
  
  
  29.     } 
    30.   
  
  
  
  30.  
    31.   
  
  
  
  31.     public String getId() { 
    32.   
  
  
  
  32.         return this.id; 
    33.   
  
  
  
  33.     } 
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35.     public void setKeepTaskList(boolean keepTaskList) { 
    36.   
  
  
  
  36.         this.keepTaskList = keepTaskList; 
    37.   
  
  
  
  37.     } 
    38.   
  
  
  
  38.  
    39.   
  
  
  
  39.     public void start() throws IllegalStateException { 
    40.   
  
  
  
  40.         this.start(""); 
    41.   
  
  
  
  41.     } 
    42.   
  
  
  
  42.  
    43.   
  
  
  
  43.     public void start(String taskName) throws IllegalStateException { 
    44.   
  
  
  
  44.         if (this.currentTaskName != null) { 
    45.   
  
  
  
  45.             throw new IllegalStateException("Can't start StopWatch: it's already running"); 
    46.   
  
  
  
  46.         } else { 
    47.   
  
  
  
  47.             this.currentTaskName = taskName; 
    48.   
  
  
  
  48.             this.startTimeNanos = System.nanoTime(); 
    49.   
  
  
  
  49.         } 
    50.   
  
  
  
  50.     } 
    51.   
  
  
  
  51.  
    52.   
  
  
  
  52.     public void stop() throws IllegalStateException { 
    53.   
  
  
  
  53.         if (this.currentTaskName == null) { 
    54.   
  
  
  
  54.             throw new IllegalStateException("Can't stop StopWatch: it's not running"); 
    55.   
  
  
  
  55.         } else { 
    56.   
  
  
  
  56.             long lastTime = System.nanoTime() - this.startTimeNanos; 
    57.   
  
  
  
  57.             this.totalTimeNanos += lastTime; 
    58.   
  
  
  
  58.             this.lastTaskInfo = new StopWatch.TaskInfo(this.currentTaskName, lastTime); 
    59.   
  
  
  
  59.             if (this.keepTaskList) { 
    60.   
  
  
  
  60.                 this.taskList.add(this.lastTaskInfo); 
    61.   
  
  
  
  61.             } 
    62.   
  
  
  
  62.  
    63.   
  
  
  
  63.             ++this.taskCount; 
    64.   
  
  
  
  64.             this.currentTaskName = null; 
    65.   
  
  
  
  65.         } 
    66.   
  
  
  
  66.     } 
    67.   
  
  
  
  67.     // .... 忽略其他代码 
    68.   
  
  
  
  68. } 
    69.

从上述 start() 和 stop() 的源码中可以看出，Spring 实现时间统计的本质还是使用了 Java 的内置方法 System.nanoTime() 来实现的。

2.Google Stopwatch 原理分析

Google Stopwatch 实现的核心源码如下：

 
 
 
 
      
  
  
  
  1. public final class Stopwatch { 
    2.   
  
  
  
  2.     private final Ticker ticker; 
    3.   
  
  
  
  3.     private boolean isRunning; 
    4.   
  
  
  
  4.     private long elapsedNanos; 
    5.   
  
  
  
  5.     private long startTick; 
    6.   
  
  
  
  6.     @CanIgnoreReturnValue 
    7.   
  
  
  
  7.     public Stopwatch start() { 
    8.   
  
  
  
  8.         Preconditions.checkState(!this.isRunning, "This stopwatch is already running."); 
    9.   
  
  
  
  9.         this.isRunning = true; 
    10.   
  
  
  
  10.         this.startTick = this.ticker.read(); 
    11.   
  
  
  
  11.         return this; 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14.     @CanIgnoreReturnValue 
    15.   
  
  
  
  15.     public Stopwatch stop() { 
    16.   
  
  
  
  16.         long tick = this.ticker.read(); 
    17.   
  
  
  
  17.         Preconditions.checkState(this.isRunning, "This stopwatch is already stopped."); 
    18.   
  
  
  
  18.         this.isRunning = false; 
    19.   
  
  
  
  19.         this.elapsedNanos += tick - this.startTick; 
    20.   
  
  
  
  20.         return this; 
    21.   
  
  
  
  21.     } 
    22.   
  
  
  
  22.     // 忽略其他源码... 
    23.   
  
  
  
  23. } 
    24.

从上述源码中可以看出 Stopwatch 对象中调用了 ticker 类来实现时间统计的，那接下来我们进入 ticker 类的实现源码：

 
 
 
 
      
  
  
  
  1. public abstract class Ticker { 
    2.   
  
  
  
  2.     private static final Ticker SYSTEM_TICKER = new Ticker() { 
    3.   
  
  
  
  3.         public long read() { 
    4.   
  
  
  
  4.             return Platform.systemNanoTime(); 
    5.   
  
  
  
  5.         } 
    6.   
  
  
  
  6.     }; 
    7.   
  
  
  
  7.     protected Ticker() { 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.     public abstract long read(); 
    10.   
  
  
  
  10.     public static Ticker systemTicker() { 
    11.   
  
  
  
  11.         return SYSTEM_TICKER; 
    12.   
  
  
  
  12.     } 
    13.   
  
  
  
  13. } 
    14.   
  
  
  
  14. final class Platform { 
    15.   
  
  
  
  15.     private static final Logger logger = Logger.getLogger(Platform.class.getName()); 
    16.   
  
  
  
  16.     private static final PatternCompiler patternCompiler = loadPatternCompiler(); 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     private Platform() { 
    19.   
  
  
  
  19.     } 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21.     static long systemNanoTime() { 
    22.   
  
  
  
  22.         return System.nanoTime(); 
    23.   
  
  
  
  23.     } 
    24.   
  
  
  
  24.     // 忽略其他源码... 
    25.   
  
  
  
  25. } 
    26.

从上述源码可以看出 Google Stopwatch 实现时间统计的本质还是调用了 Java 内置的 System.nanoTime() 来实现的。

结论

对于所有框架的 StopWatch 来说，其底层都是通过调用 Java 内置的 System.nanoTime() 得到两个时间，开始时间和结束时间，然后再通过结束时间减去开始时间来统计执行时间的。

总结

本文介绍了 6 种实现代码统计的方法，其中 3 种是 Java 内置的方法：

  • System.currentTimeMillis()
  • System.nanoTime()
  • new Date()

还介绍了 3 种常用框架 spring、commons-langs3、guava 的时间统计器 StopWatch。

在没有用到 spring、commons-langs3、guava 任意一种框架的情况下，推荐使用 System.currentTimeMillis() 或 System.nanoTime() 来实现代码统计，否则建议直接使用StopWatch 对象来统计执行时间。

知识扩展—Stopwatch 让统计更方便

StopWatch 存在的意义是让代码统计更简单，比如 Guava 中 StopWatch 使用示例如下：

 
 
 
 
      
  
  
  
  1. import com.google.common.base.Stopwatch; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.concurrent.TimeUnit; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. public class TimeIntervalTest { 
    6.   
  
  
  
  6.     public static void main(String[] args) throws InterruptedException { 
    7.   
  
  
  
  7.         // 创建并启动计时器 
    8.   
  
  
  
  8.         Stopwatch stopwatch = Stopwatch.createStarted(); 
    9.   
  
  
  
  9.         // 执行时间（1s） 
    10.   
  
  
  
  10.         Thread.sleep(1000); 
    11.   
  
  
  
  11.         // 停止计时器 
    12.   
  
  
  
  12.         stopwatch.stop(); 
    13.   
  
  
  
  13.         // 执行统计 
    14.   
  
  
  
  14.         System.out.printf("执行时长：%d 毫秒. %n", 
    15.   
  
  
  
  15.                 stopwatch.elapsed(TimeUnit.MILLISECONDS)); 
    16.   
  
  
  
  16.         // 清空计时器 
    17.   
  
  
  
  17.         stopwatch.reset(); 
    18.   
  
  
  
  18.         // 再次启动统计 
    19.   
  
  
  
  19.         stopwatch.start(); 
    20.   
  
  
  
  20.         // 执行时间（2s） 
    21.   
  
  
  
  21.         Thread.sleep(2000); 
    22.   
  
  
  
  22.         // 停止计时器 
    23.   
  
  
  
  23.         stopwatch.stop(); 
    24.   
  
  
  
  24.         // 执行统计 
    25.   
  
  
  
  25.         System.out.printf("执行时长：%d 秒. %n", 
    26.   
  
  
  
  26.                 stopwatch.elapsed(TimeUnit.MILLISECONDS)); 
    27.   
  
  
  
  27.     } 
    28.   
  
  
  
  28. } 
    29.

我们可以使用一个 Stopwatch 对象统计多段代码的执行时间，也可以通过指定时间类型直接统计出对应的时间间隔，比如我们可以指定时间的统计单位，如秒、毫秒、纳秒等类型。

当前文章：6种快速统计代码执行时间的方法，真香!
链接分享：http://www.gawzjz.com/qtweb/news5/193305.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

品牌网站设计知识

各行业网站

成都网站建设　　 　新都网站建设　　 　外贸网站建设　　 　简阳做网站　　 　广西弘博建站　　 　大橙子网站建设　　 　腾讯香港空间　　 　免备案虚拟主机　　 　重庆电商网站定制　　 　绵竹做网站　　 　建站定制开发　　 　网站托管运营　　 　重庆服务器托管　　 　成都富士康招工　　 　成都网站建设哪家好　　 　网站建设公司　　 　成都网络公司　　 　手机APP开发　　 　温江做网站　　 　成都网站推广