Java計時器工具StopWatch的具體使用
更新時間：2022年04月06日 11:49:19 作者：陳皮的JavaLib
計時器在很多地方都可以用到，本文主要介紹了Java計時器工具StopWatch的具體使用，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧
前言
平常，我們想要統(tǒng)計某一段代碼塊，或某一個方法的執(zhí)行時間，最簡單的是采用如下的方式。
package com.chenpi;
?
/**
* @author 陳皮
* @version 1.0
* @description
* @date 2022/4/2
*/
public class ChenPi {
?
public static void main(String[] args) throws InterruptedException {
long startTime = System.currentTimeMillis();
Thread.sleep(1000);
long endTime = System.currentTimeMillis();
System.out.println("執(zhí)行耗時(ms):" + (endTime - startTime));
}
?
}
?
// 輸出結(jié)果如下
執(zhí)行耗時(ms):1011但如果我們想對多個代碼段進行計時，以及每個階段計時的占比等信息，如果還是采用如上的方式就會充斥比較多的與業(yè)務無關的代碼，不夠簡潔。
Spring StopWatch
Spring 框架有個工具類 StopWatch，它可以用來對程序中代碼塊，或者方法進行計時，并且支持多階段計時，以及階段時間占比等統(tǒng)計，使用起來代碼比較簡潔，輕量。
package com.chenpi;
?
import org.springframework.util.StopWatch;
?
/**
* @author 陳皮
* @version 1.0
* @description
* @date 2022/4/2
*/
public class ChenPi {
?
public static void main(String[] args) throws InterruptedException {
// 聲明一個計時器
StopWatch stopWatch = new StopWatch("陳皮的計時器");
// 開始計時
stopWatch.start("發(fā)送MQ計時");
Thread.sleep(1000);
// 結(jié)束計時
stopWatch.stop();
// 打印統(tǒng)計
System.out.println(stopWatch.prettyPrint());
}
?
}
?
?
// 輸出結(jié)果如下
StopWatch '陳皮的計時器': running time = 1005775500 ns
---------------------------------------------
ns % Task name
---------------------------------------------
1005775500 100% 發(fā)送MQ計時Spring StopWatch 有以下幾個常用方法：
- StopWatch()：構(gòu)造一個計時器
- StopWatch(String id)：構(gòu)造一個指定 id 的計時器
- start()：創(chuàng)建一個名為空字符串的計時任務，開始計時
- start(String taskName)：創(chuàng)建一個指定名稱計時任務，開始計時
- stop()：結(jié)束當前任務的計時
- getTotalTimeNanos()：獲取全部任務的執(zhí)行時間，單位納秒
- getTotalTimeMillis()：獲取全部任務的執(zhí)行時間，單位毫秒
- shortSummary()：獲取簡單的統(tǒng)計信息
- prettyPrint()：以友好方式輸出總統(tǒng)計時間，以及各個階段任務的執(zhí)行時間
- setKeepTaskList(boolean keepTaskList)：是否在內(nèi)部的列表中存儲每一個任務
實踐例子
當程序中有多個計時器時，可通過構(gòu)造不同 id 的計時器來區(qū)分。以下演示多個不同計時器，統(tǒng)計不同階段的執(zhí)行時間。
package com.chenpi;
?
import org.springframework.util.StopWatch;
?
/**
* @author 陳皮
* @version 1.0
* @description
* @date 2022/4/2
*/
public class ChenPi {
?
public static void main(String[] args) throws InterruptedException {
m1();
m2();
}
?
private static void m1() throws InterruptedException {
?
// 聲明一個計時器
StopWatch stopWatch = new StopWatch("m1計時器");
?
stopWatch.start("查詢數(shù)據(jù)庫");
Thread.sleep(1000);
stopWatch.stop();
?
stopWatch.start("邏輯計算");
Thread.sleep(500);
stopWatch.stop();
?
System.out.println(stopWatch.prettyPrint());
}
?
private static void m2() throws InterruptedException {
?
// 聲明一個計時器
StopWatch stopWatch = new StopWatch("m2計時器");
?
stopWatch.start("遠程調(diào)用");
Thread.sleep(800);
stopWatch.stop();
?
stopWatch.start("發(fā)送MQ");
Thread.sleep(200);
stopWatch.stop();
?
System.out.println(stopWatch.prettyPrint());
}
}
?
// 輸出結(jié)果如下
StopWatch 'm1計時器': running time = 1516953200 ns
---------------------------------------------
ns % Task name
---------------------------------------------
1008091000 066% 查詢數(shù)據(jù)庫
508862200 034% 邏輯計算
?
StopWatch 'm2計時器': running time = 1013080000 ns
---------------------------------------------
ns % Task name
---------------------------------------------
809345900 080% 遠程調(diào)用
203734100 020% 發(fā)生MQ源碼分析
其實 StopWatch 底層實現(xiàn)很簡單，對于每一個任務，在任務開始和結(jié)束時刻調(diào)用System.*nanoTime*()方法獲取服務器當前的時間，然后計算每一個任務的執(zhí)行時間，存儲在內(nèi)部。內(nèi)部使用一個列表存儲不同任務階段的執(zhí)行時間，最后打印輸出。
package org.springframework.util;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.springframework.lang.Nullable;
public class StopWatch {
// 計時器id
private final String id;
// 是否將任務存儲到任務列表中
private boolean keepTaskList = true;
// 存儲全部任務的列表
private final List<TaskInfo> taskList = new ArrayList<>(1);
// 當前任務開始時間
private long startTimeNanos;
// 當前任務名稱
@Nullable
private String currentTaskName;
// 最后一個任務
@Nullable
private TaskInfo lastTaskInfo;
// 總?cè)蝿諗?shù)
private int taskCount;
// 總的執(zhí)行時間
private long totalTimeNanos;
// 構(gòu)造一個id為空字符串的計時器
public StopWatch() {
this("");
}
// 構(gòu)造一個指定id的計時器
public StopWatch(String id) {
this.id = id;
}
// 獲取計時器id
public String getId() {
return this.id;
}
public void setKeepTaskList(boolean keepTaskList) {
this.keepTaskList = keepTaskList;
}
// 開始計時
public void start() throws IllegalStateException {
start("");
}
// 開始一個指定任務名稱的計時
public void start(String taskName) throws IllegalStateException {
if (this.currentTaskName != null) {
throw new IllegalStateException("Can't start StopWatch: it's already running");
}
this.currentTaskName = taskName;
this.startTimeNanos = System.nanoTime();
}
// 停止任務計時
public void stop() throws IllegalStateException {
if (this.currentTaskName == null) {
throw new IllegalStateException("Can't stop StopWatch: it's not running");
}
long lastTime = System.nanoTime() - this.startTimeNanos;
this.totalTimeNanos += lastTime;
this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);
if (this.keepTaskList) {
this.taskList.add(this.lastTaskInfo);
}
++this.taskCount;
this.currentTaskName = null;
}
public boolean isRunning() {
return (this.currentTaskName != null);
}
@Nullable
public String currentTaskName() {
return this.currentTaskName;
}
public long getLastTaskTimeNanos() throws IllegalStateException {
if (this.lastTaskInfo == null) {
throw new IllegalStateException("No tasks run: can't get last task interval");
}
return this.lastTaskInfo.getTimeNanos();
}
public long getLastTaskTimeMillis() throws IllegalStateException {
if (this.lastTaskInfo == null) {
throw new IllegalStateException("No tasks run: can't get last task interval");
}
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");
}
return this.lastTaskInfo.getTaskName();
}
public TaskInfo getLastTaskInfo() throws IllegalStateException {
if (this.lastTaskInfo == null) {
throw new IllegalStateException("No tasks run: can't get last task info");
}
return this.lastTaskInfo;
}
public long getTotalTimeNanos() {
return this.totalTimeNanos;
}
public long getTotalTimeMillis() {
return nanosToMillis(this.totalTimeNanos);
}
public double getTotalTimeSeconds() {
return nanosToSeconds(this.totalTimeNanos);
}
public int getTaskCount() {
return this.taskCount;
}
public TaskInfo[] getTaskInfo() {
if (!this.keepTaskList) {
throw new UnsupportedOperationException("Task info is not being kept!");
}
return this.taskList.toArray(new TaskInfo[0]);
}
public String shortSummary() {
return "StopWatch '" + getId() + "': running time = " + getTotalTimeNanos() + " ns";
}
public String prettyPrint() {
StringBuilder sb = new StringBuilder(shortSummary());
sb.append('\n');
if (!this.keepTaskList) {
sb.append("No task info kept");
}
else {
sb.append("---------------------------------------------\n");
sb.append("ns % Task name\n");
sb.append("---------------------------------------------\n");
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMinimumIntegerDigits(9);
nf.setGroupingUsed(false);
NumberFormat pf = NumberFormat.getPercentInstance();
pf.setMinimumIntegerDigits(3);
pf.setGroupingUsed(false);
for (TaskInfo task : getTaskInfo()) {
sb.append(nf.format(task.getTimeNanos())).append(" ");
sb.append(pf.format((double) task.getTimeNanos() / getTotalTimeNanos())).append(" ");
sb.append(task.getTaskName()).append('\n');
}
}
return sb.toString();
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(shortSummary());
if (this.keepTaskList) {
for (TaskInfo task : getTaskInfo()) {
sb.append("; [").append(task.getTaskName()).append("] took ").append(task.getTimeNanos()).append(" ns");
long percent = Math.round(100.0 * task.getTimeNanos() / getTotalTimeNanos());
sb.append(" = ").append(percent).append('%');
}
}
else {
sb.append("; no task info kept");
}
return sb.toString();
}
private static long nanosToMillis(long duration) {
return TimeUnit.NANOSECONDS.toMillis(duration);
}
private static double nanosToSeconds(long duration) {
return duration / 1_000_000_000.0;
}
// 任務實體
public static final class TaskInfo {
// 任務名稱
private final String taskName;
// 任務執(zhí)行時間
private final long timeNanos;
TaskInfo(String taskName, long timeNanos) {
this.taskName = taskName;
this.timeNanos = timeNanos;
}
public String getTaskName() {
return this.taskName;
}
public long getTimeNanos() {
return this.timeNanos;
}
public long getTimeMillis() {
return nanosToMillis(this.timeNanos);
}
public double getTimeSeconds() {
return nanosToSeconds(this.timeNanos);
}
}
}
復制代碼StopWatch 使用起來簡潔，支持多任務階段統(tǒng)計，統(tǒng)計多任務時間占比等，統(tǒng)計結(jié)果直觀。但是它也有不好的地方，就是一個 StopWatch 實例只能同時 start 一個 task，只能等這個 task 進行 stop 之后，才能繼續(xù) start 另一個 task。注意，StopWatch 實例不是線程安全的，也沒必要進行同步處理。
lang3 StopWatch
Apache commons lang3 包下也有一個用于計時工具類 StopWatch。它還有暫停計時，恢復計時，設置分割點等功能。
org.apache.commons:commons-lang3:3.12.0 復制代碼
它主要有以下幾個常用方法：
- create()：實例化一個計時器
- createStarted()：實例化一個計時器，并開始計時
- StopWatch(final String message)：實例化一個帶有標識符的計時器
- start()：開始計時
- split()：設置分割點
- getSplitTime()：統(tǒng)計從 start 開始最后一個分割點的用時
- reset()：重置計時
- suspend()：暫停計時
- resume()：恢復計時
- stop()：停止計時
- getTime()：統(tǒng)計從 start 到當前時刻的同時
package com.chenpi;
?
import org.apache.commons.lang3.time.StopWatch;
?
/**
* @author 陳皮
* @version 1.0
* @description
* @date 2022/4/2
*/
public class ChenPi {
?
public static void main(String[] args) throws InterruptedException {
?
// 聲明一個計時器
StopWatch stopWatch = new StopWatch("m1計時器");
?
stopWatch.start();
Thread.sleep(1000);
System.out.println("start開始到現(xiàn)在的時間：" + stopWatch.getTime());
?
stopWatch.split();
Thread.sleep(500);
System.out.println("start開始到最后一個split的時間：" + stopWatch.getSplitTime());
?
stopWatch.split();
Thread.sleep(500);
System.out.println("start開始到最后一個split的時間：" + stopWatch.getSplitTime());
?
// 重置計時
stopWatch.reset();
Thread.sleep(2000);
stopWatch.start();
Thread.sleep(1000);
System.out.println("start開始到現(xiàn)在的時間：" + stopWatch.getTime());
?
// 暫停計時
stopWatch.suspend();
Thread.sleep(3000);
// 恢復計時
stopWatch.resume();
?
Thread.sleep(1000);
?
// 結(jié)束計時
stopWatch.stop();
?
Thread.sleep(1000);
?
System.out.println("start開始到stop結(jié)束的時間：" + stopWatch.getTime());
?
System.out.println(stopWatch);
}
}
?
// 輸出結(jié)果如下
start開始到現(xiàn)在的時間：1000
start開始到最后一個split的時間：1001
start開始到最后一個split的時間：1510
start開始到現(xiàn)在的時間：1004
start開始到stop結(jié)束的時間：2015
m1計時器 00:00:02.015總結(jié)
- 如果是簡單的計算執(zhí)行計時，可以使用 JDK 自帶的類獲取系統(tǒng)時間進行計時。
- 如果需要多階段計時，并且需要統(tǒng)計每個階段的執(zhí)行時間占比等信息，可以使用 StopWatch 工具類。
- 推薦使用 Spring StopWatch，因為本身我們項目使用 Spring 框架比較多，這樣就自帶了 StopWatch。
到此這篇關于Java計時器工具StopWatch的具體使用的文章就介紹到這了,更多相關Java計時器工具StopWatch內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
關于SpringCloud的微服務結(jié)構(gòu)及微服務遠程調(diào)用
Spring Cloud 是一套完整的微服務解決方案，基于 Spring Boot 框架，準確的說，它不是一個框架，而是一個大的容器，它將市面上較好的微服務框架集成進來，從而簡化了開發(fā)者的代碼量,需要的朋友可以參考下2023-05-05
java.lang.ThreadLocal該類提供了線程局部變量,用于在當前線程中共享數(shù)據(jù),本文主要介紹了Java中ThreadLocal共享變量的使用,具有一定的參考價值,感興趣的可以了解一下2024-01-01
Spring AOP 對象內(nèi)部方法間的嵌套調(diào)用方式
這篇文章主要介紹了Spring AOP 對象內(nèi)部方法間的嵌套調(diào)用方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-08-08
這篇文章主要為大家詳細介紹了Java獲取當前時間年月日的方法，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-11-11
這篇文章主要介紹了java中的OPT算法實現(xiàn)方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-07-07
IDEA啟動服務提示端口被占用,Web?server?failed?to?start.Port?was?al
這篇文章主要介紹了IDEA啟動服務提示端口被占用，Web?server?failed?to?start.Port?was?already?in?use.,本文給大家分享解決方案，分為linux系統(tǒng)和windows系統(tǒng)解決方案，需要的朋友可以參考下2023-07-07
這篇文章主要介紹了JAVA 連等賦值問題，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2019-03-03
IDEA下SpringBoot指定環(huán)境、配置文件啟動操作過程
這篇文章主要介紹了IDEA下SpringBoot指定環(huán)境、配置文件啟動過程，本文通過實例代碼給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-08-08
ssm框架Springmvc文件上傳實現(xiàn)代碼詳解
這篇文章主要介紹了ssm框架Springmvc文件上傳實現(xiàn)代碼詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2020-07-07
Java創(chuàng)建型設計模式之抽象工廠模式(Abstract?Factory)
當系統(tǒng)所提供的工廠所需生產(chǎn)的具體產(chǎn)品并不是一個簡單的對象，而是多個位于不同產(chǎn)品等級結(jié)構(gòu)中屬于不同類型的具體產(chǎn)品時需要使用抽象工廠模式，抽象工廠模式是所有形式的工廠模式中最為抽象和最具一般性的一種形態(tài)2022-09-09