Java项目计算程序执行时间方法

一、总结

1.1、使用System.currentTimeMillis();计算程序执行毫秒数

1.                 // 开始时间1
2.                 long startTime1 = System.currentTimeMillis();
3.                 Thread.sleep(100);
4.                 // 结束时间1
5.                 long endTime1 = System.currentTimeMillis();
7.                 // 开始时间2
8.                 long startTime2 = System.currentTimeMillis();
9.                 Thread.sleep(200);
10.                 // 结束时间2
11.                 long endTime2 = System.currentTimeMillis();
12.                 System.out.println("逻辑1执行时间："+ (endTime1 - startTime1));
13.                 System.out.println("逻辑2执行时间："+ (endTime2 -startTime2));

复制代码

1.2、使用org.springframework.util包下的一个工具类StopWatch计算执行时间

1.                 StopWatch testTask = new StopWatch("TestTask");
2.                 // 记录开始时间点
3.                 testTask.start("task1");
4.                 Thread.sleep(100);
5.                 // 记录结束时间点
6.                 testTask.stop();
7.                 // 记录开始时间点
8.                 testTask.start("task2");
9.                 Thread.sleep(200);
10.                 // 记录结束时间点
11.                 testTask.stop();
12.                 // 输出执行时间
13.                 System.out.println("==任务执行时间==");
14.                 System.out.println(testTask.prettyPrint());
15.                 System.out.println("执行任务的毫秒数："+testTask.getTotalTimeMillis());

复制代码

1.3两个案例的完整代码、执行结果

1. package time.stopwatch;import org.springframework.util.StopWatch;public class StopWatchTest {                public static void main(String[] args) throws InterruptedException {                // 计算执行时间                calculateExecuteTime1();                // 计算执行时间                calculateExecuteTime2();        }        public static void calculateExecuteTime1() throws InterruptedException {                // 开始时间1
2.                 long startTime1 = System.currentTimeMillis();
3.                 Thread.sleep(100);
4.                 // 结束时间1
5.                 long endTime1 = System.currentTimeMillis();
7.                 // 开始时间2
8.                 long startTime2 = System.currentTimeMillis();
9.                 Thread.sleep(200);
10.                 // 结束时间2
11.                 long endTime2 = System.currentTimeMillis();
12.                 System.out.println("逻辑1执行时间："+ (endTime1 - startTime1));
13.                 System.out.println("逻辑2执行时间："+ (endTime2 -startTime2));        }        public static void calculateExecuteTime2() throws InterruptedException {                StopWatch testTask = new StopWatch("TestTask");
14.                 // 记录开始时间点
15.                 testTask.start("task1");
16.                 Thread.sleep(100);
17.                 // 记录结束时间点
18.                 testTask.stop();
19.                 // 记录开始时间点
20.                 testTask.start("task2");
21.                 Thread.sleep(200);
22.                 // 记录结束时间点
23.                 testTask.stop();
24.                 // 输出执行时间
25.                 System.out.println("==任务执行时间==");
26.                 System.out.println(testTask.prettyPrint());
27.                 System.out.println("执行任务的毫秒数："+testTask.getTotalTimeMillis());        }}

复制代码

执行结果：

1. 逻辑1执行时间：109
2. 逻辑2执行时间：203
3. ==任务执行时间==
4. StopWatch 'TestTask': running time = 319076700 ns
5. ---------------------------------------------
6. ns         %     Task name
7. ---------------------------------------------
8. 114748000  036%  task1
9. 204328700  064%  task2
11. 执行任务的毫秒数：319

复制代码

1.4 StopWatch优缺点：

优点：
1、spring自带工具类，可直接使用
2、代码实现简单，使用更简单
3、统一归纳，展示每项任务耗时与占用总时间的百分比，展示结果直观
4、性能消耗相对较小，并且最大程度的保证了start与stop之间的时间记录的准确性
5、可在start时直接指定任务名字，从而更加直观的显示记录结果
缺点：
1、一个StopWatch实例一次只能开启一个task，不能同时start多个task，并且在该task未stop之前不能start一个新的task，必须在该task stop之后才能开启新的task，若要一次开启多个，需要new不同的StopWatch实例
2、代码侵入式使用，需要改动多处代码
1.5、spring中StopWatch源码实现如下：

1. import java.text.NumberFormat;
2. import java.util.LinkedList;
3. import java.util.List;
5. public class StopWatch {
6.         private final String id;
7.         private boolean keepTaskList = true;
8.         private final List<TaskInfo> taskList = new LinkedList();
9.         private long startTimeMillis;
10.         private boolean running;
11.         private String currentTaskName;
12.         private StopWatch.TaskInfo lastTaskInfo;
13.         private int taskCount;
14.         private long totalTimeMillis;
16.         public StopWatch() {
17.                 this.id = "";
18.         }
20.         public StopWatch(String id) {
21.                 this.id = id;
22.         }
24.         public void setKeepTaskList(boolean keepTaskList) {
25.                 this.keepTaskList = keepTaskList;
26.         }
28.         public void start() throws IllegalStateException {
29.                 this.start("");
30.         }
32.         public void start(String taskName) throws IllegalStateException {
33.                 if (this.running) {
34.                         throw new IllegalStateException("Can't start StopWatch: it's already running");
35.                 } else {
36.                         this.startTimeMillis = System.currentTimeMillis();
37.                         this.running = true;
38.                         this.currentTaskName = taskName;
39.                 }
40.         }
42.         public void stop() throws IllegalStateException {
43.                 if (!this.running) {
44.                         throw new IllegalStateException("Can't stop StopWatch: it's not running");
45.                 } else {
46.                         long lastTime = System.currentTimeMillis() - this.startTimeMillis;
47.                         this.totalTimeMillis += lastTime;
48.                         this.lastTaskInfo = new StopWatch.TaskInfo(this.currentTaskName, lastTime);
49.                         if (this.keepTaskList) {
50.                                 this.taskList.add(this.lastTaskInfo);
51.                         }
53.                         ++this.taskCount;
54.                         this.running = false;
55.                         this.currentTaskName = null;
56.                 }
57.         }
59.         public boolean isRunning() {
60.                 return this.running;
61.         }
63.         public long getLastTaskTimeMillis() throws IllegalStateException {
64.                 if (this.lastTaskInfo == null) {
65.                         throw new IllegalStateException("No tasks run: can't get last task interval");
66.                 } else {
67.                         return this.lastTaskInfo.getTimeMillis();
68.                 }
69.         }
71.         public String getLastTaskName() throws IllegalStateException {
72.                 if (this.lastTaskInfo == null) {
73.                         throw new IllegalStateException("No tasks run: can't get last task name");
74.                 } else {
75.                         return this.lastTaskInfo.getTaskName();
76.                 }
77.         }
79.         public StopWatch.TaskInfo getLastTaskInfo() throws IllegalStateException {
80.                 if (this.lastTaskInfo == null) {
81.                         throw new IllegalStateException("No tasks run: can't get last task info");
82.                 } else {
83.                         return this.lastTaskInfo;
84.                 }
85.         }
87.         public long getTotalTimeMillis() {
88.                 return this.totalTimeMillis;
89.         }
91.         public double getTotalTimeSeconds() {
92.                 return (double) this.totalTimeMillis / 1000.0D;
93.         }
95.         public int getTaskCount() {
96.                 return this.taskCount;
97.         }
99.         public StopWatch.TaskInfo[] getTaskInfo() {
100.                 if (!this.keepTaskList) {
101.                         throw new UnsupportedOperationException("Task info is not being kept!");
102.                 } else {
103.                         return (StopWatch.TaskInfo[]) this.taskList.toArray(new StopWatch.TaskInfo[this.taskList.size()]);
104.                 }
105.         }
107.         public String shortSummary() {
108.                 return "StopWatch '" + this.id + "': running time (millis) = " + this.getTotalTimeMillis();
109.         }
111.         public String prettyPrint() {
112.                 StringBuilder sb = new StringBuilder(this.shortSummary());
113.                 sb.append('\n');
114.                 if (!this.keepTaskList) {
115.                         sb.append("No task info kept");
116.                 } else {
117.                         sb.append("-----------------------------------------\n");
118.                         sb.append("ms     %     Task name\n");
119.                         sb.append("-----------------------------------------\n");
120.                         NumberFormat nf = NumberFormat.getNumberInstance();
121.                         nf.setMinimumIntegerDigits(5);
122.                         nf.setGroupingUsed(false);
123.                         NumberFormat pf = NumberFormat.getPercentInstance();
124.                         pf.setMinimumIntegerDigits(3);
125.                         pf.setGroupingUsed(false);
126.                         StopWatch.TaskInfo[] var7;
127.                         int var6 = (var7 = this.getTaskInfo()).length;
129.                         for (int var5 = 0; var5 < var6; ++var5) {
130.                                 StopWatch.TaskInfo task = var7[var5];
131.                                 sb.append(nf.format(task.getTimeMillis())).append("  ");
132.                                 sb.append(pf.format(task.getTimeSeconds() / this.getTotalTimeSeconds())).append("  ");
133.                                 sb.append(task.getTaskName()).append("\n");
134.                         }
135.                 }
137.                 return sb.toString();
138.         }
140.         @Override
141.         public String toString() {
142.                 StringBuilder sb = new StringBuilder(this.shortSummary());
143.                 if (this.keepTaskList) {
144.                         StopWatch.TaskInfo[] var5;
145.                         int var4 = (var5 = this.getTaskInfo()).length;
147.                         for (int var3 = 0; var3 < var4; ++var3) {
148.                                 StopWatch.TaskInfo task = var5[var3];
149.                                 sb.append("; [").append(task.getTaskName()).append("] took ").append(task.getTimeMillis());
150.                                 long percent = Math.round(100.0D * task.getTimeSeconds() / this.getTotalTimeSeconds());
151.                                 sb.append(" = ").append(percent).append("%");
152.                         }
153.                 } else {
154.                         sb.append("; no task info kept");
155.                 }
157.                 return sb.toString();
158.         }
160.         public static final class TaskInfo {
161.                 private final String taskName;
162.                 private final long timeMillis;
164.                 TaskInfo(String taskName, long timeMillis) {
165.                         this.taskName = taskName;
166.                         this.timeMillis = timeMillis;
167.                 }
169.                 public String getTaskName() {
170.                         return this.taskName;
171.                 }
173.                 public long getTimeMillis() {
174.                         return this.timeMillis;
175.                 }
177.                 public double getTimeSeconds() {
178.                         return (double) this.timeMillis / 1000.0D;
179.                 }
180.         }
182. }

复制代码

原文摘录至：https://blog.csdn.net/gxs1688/article/details/87185030
致敬原作者：一个不二，侵删。

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！