时间监视器 StopWatch

时间:2022-12-24 20:15:25

转载地址:http://blog.csdn.net/lxzo123/article/details/6608162

spring-framework提供了一个StopWatch类可以做类似任务执行时间控制,也就是封装了一个对开始时间,结束时间记录操作的Java类,当然还有一些其他控制,代码如下:

[java] view plain copy
  1. /* 
  2.  * Copyright 2002-2010 the original author or authors. 
  3.  * 
  4.  * Licensed under the Apache License, Version 2.0 (the "License"); 
  5.  * you may not use this file except in compliance with the License. 
  6.  * You may obtain a copy of the License at 
  7.  * 
  8.  *      http://www.apache.org/licenses/LICENSE-2.0 
  9.  * 
  10.  * Unless required by applicable law or agreed to in writing, software 
  11.  * distributed under the License is distributed on an "AS IS" BASIS, 
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13.  * See the License for the specific language governing permissions and 
  14.  * limitations under the License. 
  15.  */  
  16.   
  17. package com.test;  
  18.   
  19. import java.text.NumberFormat;  
  20. import java.util.LinkedList;  
  21. import java.util.List;  
  22.   
  23. /** 
  24.  * Simple stop watch, allowing for timing of a number of tasks, 
  25.  * exposing total running time and running time for each named task. 
  26.  * 
  27.  * <p>Conceals use of <code>System.currentTimeMillis()</code>, improving the 
  28.  * readability of application code and reducing the likelihood of calculation errors. 
  29.  * 
  30.  * <p>Note that this object is not designed to be thread-safe and does not 
  31.  * use synchronization. 
  32.  * 
  33.  * <p>This class is normally used to verify performance during proof-of-concepts 
  34.  * and in development, rather than as part of production applications. 
  35.  * 
  36.  * @author Rod Johnson 
  37.  * @author Juergen Hoeller 
  38.  * @author Sam Brannen 
  39.  * @since May 2, 2001 
  40.  */  
  41. public class StopWatch {  
  42.   
  43.     /** 
  44.      * Identifier of this stop watch. 
  45.      * Handy when we have output from multiple stop watches 
  46.      * and need to distinguish between them in log or console output. 
  47.      */  
  48.     private final String id;  
  49.   
  50.     private boolean keepTaskList = true;  
  51.   
  52.     private final List<TaskInfo> taskList = new LinkedList<TaskInfo>();  
  53.   
  54.     /** Start time of the current task */  
  55.     private long startTimeMillis;  
  56.   
  57.     /** Is the stop watch currently running? */  
  58.     private boolean running;  
  59.   
  60.     /** Name of the current task */  
  61.     private String currentTaskName;  
  62.   
  63.     private TaskInfo lastTaskInfo;  
  64.   
  65.     private int taskCount;  
  66.   
  67.     /** Total running time */  
  68.     private long totalTimeMillis;  
  69.   
  70.   
  71.     /** 
  72.      * Construct a new stop watch. Does not start any task. 
  73.      */  
  74.     public StopWatch() {  
  75.         this.id = "";  
  76.     }  
  77.   
  78.     /** 
  79.      * Construct a new stop watch with the given id. 
  80.      * Does not start any task. 
  81.      * @param id identifier for this stop watch. 
  82.      * Handy when we have output from multiple stop watches 
  83.      * and need to distinguish between them. 
  84.      */  
  85.     public StopWatch(String id) {  
  86.         this.id = id;  
  87.     }  
  88.   
  89.   
  90.     /** 
  91.      * Determine whether the TaskInfo array is built over time. Set this to 
  92.      * "false" when using a StopWatch for millions of intervals, or the task 
  93.      * info structure will consume excessive memory. Default is "true". 
  94.      */  
  95.     public void setKeepTaskList(boolean keepTaskList) {  
  96.         this.keepTaskList = keepTaskList;  
  97.     }  
  98.   
  99.   
  100.     /** 
  101.      * Start an unnamed task. The results are undefined if {@link #stop()} 
  102.      * or timing methods are called without invoking this method. 
  103.      * @see #stop() 
  104.      */  
  105.     public void start() throws IllegalStateException {  
  106.         start("");  
  107.     }  
  108.   
  109.     /** 
  110.      * Start a named task. The results are undefined if {@link #stop()} 
  111.      * or timing methods are called without invoking this method. 
  112.      * @param taskName the name of the task to start 
  113.      * @see #stop() 
  114.      */  
  115.     public void start(String taskName) throws IllegalStateException {  
  116.         if (this.running) {  
  117.             throw new IllegalStateException("Can't start StopWatch: it's already running");  
  118.         }  
  119.         this.startTimeMillis = System.currentTimeMillis();  
  120.         this.running = true;  
  121.         this.currentTaskName = taskName;  
  122.     }  
  123.   
  124.     /** 
  125.      * Stop the current task. The results are undefined if timing 
  126.      * methods are called without invoking at least one pair 
  127.      * {@link #start()} / {@link #stop()} methods. 
  128.      * @see #start() 
  129.      */  
  130.     public void stop() throws IllegalStateException {  
  131.         if (!this.running) {  
  132.             throw new IllegalStateException("Can't stop StopWatch: it's not running");  
  133.         }  
  134.         long lastTime = System.currentTimeMillis() - this.startTimeMillis;  
  135.         this.totalTimeMillis += lastTime;  
  136.         this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);  
  137.         if (this.keepTaskList) {  
  138.             this.taskList.add(lastTaskInfo);  
  139.         }  
  140.         ++this.taskCount;  
  141.         this.running = false;  
  142.         this.currentTaskName = null;  
  143.     }  
  144.   
  145.     /** 
  146.      * Return whether the stop watch is currently running. 
  147.      */  
  148.     public boolean isRunning() {  
  149.         return this.running;  
  150.     }  
  151.   
  152.   
  153.     /** 
  154.      * Return the time taken by the last task. 
  155.      */  
  156.     public long getLastTaskTimeMillis() throws IllegalStateException {  
  157.         if (this.lastTaskInfo == null) {  
  158.             throw new IllegalStateException("No tasks run: can't get last task interval");  
  159.         }  
  160.         return this.lastTaskInfo.getTimeMillis();  
  161.     }  
  162.   
  163.     /** 
  164.      * Return the name of the last task. 
  165.      */  
  166.     public String getLastTaskName() throws IllegalStateException {  
  167.         if (this.lastTaskInfo == null) {  
  168.             throw new IllegalStateException("No tasks run: can't get last task name");  
  169.         }  
  170.         return this.lastTaskInfo.getTaskName();  
  171.     }  
  172.   
  173.     /** 
  174.      * Return the last task as a TaskInfo object. 
  175.      */  
  176.     public TaskInfo getLastTaskInfo() throws IllegalStateException {  
  177.         if (this.lastTaskInfo == null) {  
  178.             throw new IllegalStateException("No tasks run: can't get last task info");  
  179.         }  
  180.         return this.lastTaskInfo;  
  181.     }  
  182.   
  183.   
  184.     /** 
  185.      * Return the total time in milliseconds for all tasks. 
  186.      */  
  187.     public long getTotalTimeMillis() {  
  188.         return this.totalTimeMillis;  
  189.     }  
  190.   
  191.     /** 
  192.      * Return the total time in seconds for all tasks. 
  193.      */  
  194.     public double getTotalTimeSeconds() {  
  195.         return this.totalTimeMillis / 1000.0;  
  196.     }  
  197.   
  198.     /** 
  199.      * Return the number of tasks timed. 
  200.      */  
  201.     public int getTaskCount() {  
  202.         return this.taskCount;  
  203.     }  
  204.   
  205.     /** 
  206.      * Return an array of the data for tasks performed. 
  207.      */  
  208.     public TaskInfo[] getTaskInfo() {  
  209.         if (!this.keepTaskList) {  
  210.             throw new UnsupportedOperationException("Task info is not being kept!");  
  211.         }  
  212.         return this.taskList.toArray(new TaskInfo[this.taskList.size()]);  
  213.     }  
  214.   
  215.   
  216.     /** 
  217.      * Return a short description of the total running time. 
  218.      */  
  219.     public String shortSummary() {  
  220.         return "StopWatch '" + this.id + "': running time (millis) = " + getTotalTimeMillis();  
  221.     }  
  222.   
  223.     /** 
  224.      * Return a string with a table describing all tasks performed. 
  225.      * For custom reporting, call getTaskInfo() and use the task info directly. 
  226.      */  
  227.     public String prettyPrint() {  
  228.         StringBuilder sb = new StringBuilder(shortSummary());  
  229.         sb.append('\n');  
  230.         if (!this.keepTaskList) {  
  231.             sb.append("No task info kept");  
  232.         } else {  
  233.             sb.append("-----------------------------------------\n");  
  234.             sb.append("ms     %     Task name\n");  
  235.             sb.append("-----------------------------------------\n");  
  236.             NumberFormat nf = NumberFormat.getNumberInstance();  
  237.             nf.setMinimumIntegerDigits(5);  
  238.             nf.setGroupingUsed(false);  
  239.             NumberFormat pf = NumberFormat.getPercentInstance();  
  240.             pf.setMinimumIntegerDigits(3);  
  241.             pf.setGroupingUsed(false);  
  242.             for (TaskInfo task : getTaskInfo()) {  
  243.                 sb.append(nf.format(task.getTimeMillis())).append("  ");  
  244.                 sb.append(pf.format(task.getTimeSeconds() / getTotalTimeSeconds())).append("  ");  
  245.                 sb.append(task.getTaskName()).append("\n");  
  246.             }  
  247.         }  
  248.         return sb.toString();  
  249.     }  
  250.   
  251.     /** 
  252.      * Return an informative string describing all tasks performed 
  253.      * For custom reporting, call <code>getTaskInfo()</code> and use the task info directly. 
  254.      */  
  255.     @Override  
  256.     public String toString() {  
  257.         StringBuilder sb = new StringBuilder(shortSummary());  
  258.         if (this.keepTaskList) {  
  259.             for (TaskInfo task : getTaskInfo()) {  
  260.                 sb.append("; [").append(task.getTaskName()).append("] took ").append(task.getTimeMillis());  
  261.                 long percent = Math.round((100.0 * task.getTimeSeconds()) / getTotalTimeSeconds());  
  262.                 sb.append(" = ").append(percent).append("%");  
  263.             }  
  264.         } else {  
  265.             sb.append("; no task info kept");  
  266.         }  
  267.         return sb.toString();  
  268.     }  
  269.   
  270.   
  271.     /** 
  272.      * Inner class to hold data about one task executed within the stop watch. 
  273.      */  
  274.     public static final class TaskInfo {  
  275.   
  276.         private final String taskName;  
  277.   
  278.         private final long timeMillis;  
  279.   
  280.         TaskInfo(String taskName, long timeMillis) {  
  281.             this.taskName = taskName;  
  282.             this.timeMillis = timeMillis;  
  283.         }  
  284.   
  285.         /** 
  286.          * Return the name of this task. 
  287.          */  
  288.         public String getTaskName() {  
  289.             return this.taskName;  
  290.         }  
  291.   
  292.         /** 
  293.          * Return the time in milliseconds this task took. 
  294.          */  
  295.         public long getTimeMillis() {  
  296.             return this.timeMillis;  
  297.         }  
  298.   
  299.         /** 
  300.          * Return the time in seconds this task took. 
  301.          */  
  302.         public double getTimeSeconds() {  
  303.             return this.timeMillis / 1000.0;  
  304.         }  
  305.     }  
  306.       
  307.     /** 
  308.      * test 
  309.      * @throws InterruptedException  
  310.      */  
  311.     public static void main(String[] args) throws InterruptedException{  
  312.         StopWatch first = new StopWatch("First");  
  313.         first.start("A");  
  314.         Thread.sleep(200);  
  315.         first.stop();  
  316.         first.start("B");  
  317.         Thread.sleep(200);  
  318.         first.stop();  
  319.         first.start("C");  
  320.         Thread.sleep(120);  
  321.         first.stop();  
  322.         System.out.println(first.prettyPrint());  
  323.           
  324.     }  
  325. }  

执行结果如下:

[plain] view plain copy
  1. StopWatch 'First': running time (millis) = 516  
  2. -----------------------------------------  
  3. ms     %     Task name  
  4. -----------------------------------------  
  5. 00203  039%  A  
  6. 00203  039%  B  
  7. 00110  021%  C  
打印每个任务执行时间,以及占总时间百分比