apache StopWatch基本使用

大家好，又见面了，我是你们的朋友全栈君。

转载自：http://blog.csdn.net/eg366/article/details/11835191

pom:

[html]
view plain
copy
 <dependency>  
     <groupId>commons-lang</groupId>  
     <artifactId>commons-lang</artifactId>  
     <version>2.6</version>  
 </dependency>  

org.apache.commons.lang.time.StopWatch

（1）

[java]
view plain
copy
 private static void test01() throws InterruptedException {  
     StopWatch watch = new StopWatch();  
     watch.start();  
     Thread.sleep(1000);  
     watch.split();  
     /* 
      * This is the time between start and latest split. 
      * 调用start()方法到最后一次调用split()方法耗用的时间 
      */  
     System.out.println(watch.getSplitTime());  
     Thread.sleep(2000);  
     watch.split();  
     System.out.println(watch.getSplitTime());  
     Thread.sleep(500);  
     watch.stop();  
     /* 
      * This is either the time between the start and the moment this method 
      * is called, or the amount of time between start and stop 
      * 调用start()方法到调用getTime()或stop()方法耗用的时间 
      */  
     System.out.println(watch.getTime());  
 }  

打印信息：

[plain]
view plain
copy
 1000  
 3000  
 3500  

（2）

[java]
view plain
copy
 private static void test02() throws InterruptedException {  
     StopWatch watch = new StopWatch();  
     watch.start();  
     Thread.sleep(1000);  
     System.out.println(watch.getTime());  
     /* 复位 归零 */  
     watch.reset();  
     watch.start();  
     Thread.sleep(1000);  
     System.out.println(watch.getTime());  
 }  

打印信息：

[plain]
view plain
copy
 1000  
 1000  

（3）

[java]
view plain
copy
 private static void test03() throws InterruptedException {  
     StopWatch watch = new StopWatch();  
     watch.start();  
     Thread.sleep(1000);  
     System.out.println(watch.getTime());  
     /* 暂停 */  
     watch.suspend();  
     System.out.println(“do something”);  
     Thread.sleep(500);  
     /* 恢复 */  
     watch.resume();  
     Thread.sleep(2000);  
     System.out.println(watch.getTime());  
 }  

打印信息：

[plain]
view plain
copy
 1000  
 do something  
 3000  

转载自：http://blog.csdn.net/lxzo123/article/details/6608162

有时我们在做开发的时候需要记录每个任务执行时间，或者记录一段代码执行时间，最简单的方法就是打印当前时间与执行完时间的差值，然后这样如果执行大量测试的话就很麻烦，并且不直观，如果想对执行的时间做进一步控制，则需要在程序中很多地方修改，目前spring-framework提供了一个StopWatch类可以做类似任务执行时间控制，也就是封装了一个对开始时间，结束时间记录操作的java类，当然还有一些其他控制，代码如下：

[java]
view plain
copy
 /* 
  * Copyright 2002-2010 the original author or authors. 
  * 
  * Licensed under the Apache License, Version 2.0 (the “License”); 
  * you may not use this file except in compliance with the License. 
  * You may obtain a copy of the License at 
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0 
  * 
  * Unless required by applicable law or agreed to in writing, software 
  * distributed under the License is distributed on an “AS IS” BASIS, 
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  * See the License for the specific language governing permissions and 
  * limitations under the License. 
  */  
   
 package com.test;  
   
 import java.text.NumberFormat;  
 import java.util.LinkedList;  
 import java.util.List;  
   
 /** 
  * Simple stop watch, allowing for timing of a number of tasks, 
  * exposing total running time and running time for each named task. 
  * 
  * <p>Conceals use of <code>System.currentTimeMillis()</code>, improving the 
  * readability of application code and reducing the likelihood of calculation errors. 
  * 
  * <p>Note that this object is not designed to be thread-safe and does not 
  * use synchronization. 
  * 
  * <p>This class is normally used to verify performance during proof-of-concepts 
  * and in development, rather than as part of production applications. 
  * 
  * @author Rod Johnson 
  * @author Juergen Hoeller 
  * @author Sam Brannen 
  * @since May 2, 2001 
  */  
 public class StopWatch {  
   
     /** 
      * Identifier of this stop watch. 
      * Handy when we have output from multiple stop watches 
      * and need to distinguish between them in log or console output. 
      */  
     private final String id;  
   
     private boolean keepTaskList = true;  
   
     private final List<TaskInfo> taskList = new LinkedList<TaskInfo>();  
   
     /** Start time of the current task */  
     private long startTimeMillis;  
   
     /** Is the stop watch currently running? */  
     private boolean running;  
   
     /** Name of the current task */  
     private String currentTaskName;  
   
     private TaskInfo lastTaskInfo;  
   
     private int taskCount;  
   
     /** Total running time */  
     private long totalTimeMillis;  
   
   
     /** 
      * Construct a new stop watch. Does not start any task. 
      */  
     public StopWatch() {  
         this.id = “”;  
     }  
   
     /** 
      * Construct a new stop watch with the given id. 
      * Does not start any task. 
      * @param id identifier for this stop watch. 
      * Handy when we have output from multiple stop watches 
      * and need to distinguish between them. 
      */  
     public StopWatch(String id) {  
         this.id = id;  
     }  
   
   
     /** 
      * Determine whether the TaskInfo array is built over time. Set this to 
      * “false” when using a StopWatch for millions of intervals, or the task 
      * info structure will consume excessive memory. Default is “true”. 
      */  
     public void setKeepTaskList(boolean keepTaskList) {  
         this.keepTaskList = keepTaskList;  
     }  
   
   
     /** 
      * Start an unnamed task. The results are undefined if {@link #stop()} 
      * or timing methods are called without invoking this method. 
      * @see #stop() 
      */  
     public void start() throws IllegalStateException {  
         start(“”);  
     }  
   
     /** 
      * Start a named task. The results are undefined if {@link #stop()} 
      * or timing methods are called without invoking this method. 
      * @param taskName the name of the task to start 
      * @see #stop() 
      */  
     public void start(String taskName) throws IllegalStateException {  
         if (this.running) {  
             throw new IllegalStateException(“Can’t start StopWatch: it’s already running”);  
         }  
         this.startTimeMillis = System.currentTimeMillis();  
         this.running = true;  
         this.currentTaskName = taskName;  
     }  
   
     /** 
      * Stop the current task. The results are undefined if timing 
      * methods are called without invoking at least one pair 
      * {@link #start()} / {@link #stop()} methods. 
      * @see #start() 
      */  
     public void stop() throws IllegalStateException {  
         if (!this.running) {  
             throw new IllegalStateException(“Can’t stop StopWatch: it’s not running”);  
         }  
         long lastTime = System.currentTimeMillis() – this.startTimeMillis;  
         this.totalTimeMillis += lastTime;  
         this.lastTaskInfo = new TaskInfo(this.currentTaskName, lastTime);  
         if (this.keepTaskList) {  
             this.taskList.add(lastTaskInfo);  
         }  
         ++this.taskCount;  
         this.running = false;  
         this.currentTaskName = null;  
     }  
   
     /** 
      * Return whether the stop watch is currently running. 
      */  
     public boolean isRunning() {  
         return this.running;  
     }  
   
   
     /** 
      * Return the time taken by the last task. 
      */  
     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();  
     }  
   
     /** 
      * Return the name of the last task. 
      */  
     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();  
     }  
   
     /** 
      * Return the last task as a TaskInfo object. 
      */  
     public TaskInfo getLastTaskInfo() throws IllegalStateException {  
         if (this.lastTaskInfo == null) {  
             throw new IllegalStateException(“No tasks run: can’t get last task info”);  
         }  
         return this.lastTaskInfo;  
     }  
   
   
     /** 
      * Return the total time in milliseconds for all tasks. 
      */  
     public long getTotalTimeMillis() {  
         return this.totalTimeMillis;  
     }  
   
     /** 
      * Return the total time in seconds for all tasks. 
      */  
     public double getTotalTimeSeconds() {  
         return this.totalTimeMillis / 1000.0;  
     }  
   
     /** 
      * Return the number of tasks timed. 
      */  
     public int getTaskCount() {  
         return this.taskCount;  
     }  
   
     /** 
      * Return an array of the data for tasks performed. 
      */  
     public TaskInfo[] getTaskInfo() {  
         if (!this.keepTaskList) {  
             throw new UnsupportedOperationException(“Task info is not being kept!”);  
         }  
         return this.taskList.toArray(new TaskInfo[this.taskList.size()]);  
     }  
   
   
     /** 
      * Return a short description of the total running time. 
      */  
     public String shortSummary() {  
         return “StopWatch ‘” + this.id + “‘: running time (millis) = “ + getTotalTimeMillis();  
     }  
   
     /** 
      * Return a string with a table describing all tasks performed. 
      * For custom reporting, call getTaskInfo() and use the task info directly. 
      */  
     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(“ms     %     Task name\n”);  
             sb.append(“—————————————–\n”);  
             NumberFormat nf = NumberFormat.getNumberInstance();  
             nf.setMinimumIntegerDigits(5);  
             nf.setGroupingUsed(false);  
             NumberFormat pf = NumberFormat.getPercentInstance();  
             pf.setMinimumIntegerDigits(3);  
             pf.setGroupingUsed(false);  
             for (TaskInfo task : getTaskInfo()) {  
                 sb.append(nf.format(task.getTimeMillis())).append(”  “);  
                 sb.append(pf.format(task.getTimeSeconds() / getTotalTimeSeconds())).append(”  “);  
                 sb.append(task.getTaskName()).append(“\n”);  
             }  
         }  
         return sb.toString();  
     }  
   
     /** 
      * Return an informative string describing all tasks performed 
      * For custom reporting, call <code>getTaskInfo()</code> and use the task info directly. 
      */  
     @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.getTimeMillis());  
                 long percent = Math.round((100.0 * task.getTimeSeconds()) / getTotalTimeSeconds());  
                 sb.append(” = “).append(percent).append(“%”);  
             }  
         } else {  
             sb.append(“; no task info kept”);  
         }  
         return sb.toString();  
     }  
   
   
     /** 
      * Inner class to hold data about one task executed within the stop watch. 
      */  
     public static final class TaskInfo {  
   
         private final String taskName;  
   
         private final long timeMillis;  
   
         TaskInfo(String taskName, long timeMillis) {  
             this.taskName = taskName;  
             this.timeMillis = timeMillis;  
         }  
   
         /** 
          * Return the name of this task. 
          */  
         public String getTaskName() {  
             return this.taskName;  
         }  
   
         /** 
          * Return the time in milliseconds this task took. 
          */  
         public long getTimeMillis() {  
             return this.timeMillis;  
         }  
   
         /** 
          * Return the time in seconds this task took. 
          */  
         public double getTimeSeconds() {  
             return this.timeMillis / 1000.0;  
         }  
     }  
       
     /** 
      * test 
      * @throws InterruptedException  
      */  
     public static void main(String[] args) throws InterruptedException{  
         StopWatch first = new StopWatch(“First”);  
         first.start(“A”);  
         Thread.sleep(200);  
         first.stop();  
         first.start(“B”);  
         Thread.sleep(200);  
         first.stop();  
         first.start(“C”);  
         Thread.sleep(120);  
         first.stop();  
         System.out.println(first.prettyPrint());  
           
     }  
 }  

执行结果如下：

[plain]
view plain
copy
 StopWatch ‘First’: running time (millis) = 516  
 —————————————–  
 ms     %     Task name  
 —————————————–  
 00203  039%  A  
 00203  039%  B  
 00110  021%  C  