Java/Development Class/StopWatch — различия между версиями
Admin (обсуждение | вклад) м (1 версия) |
|
(нет различий)
|
Текущая версия на 10:01, 1 июня 2010
Содержание
- 1 Basic Timer
- 2 Provides the programatic analog of a physical stop watch
- 3 Provides various features related to the current date and time
- 4 Simple stop watch
- 5 Simulates a stop watch with a lap counter.
- 6 Some simple stop watch.
- 7 Stop Watch from JGraphT
- 8 Stopwatch is a debugging tool for manually profiling code execution
- 9 StopWatch provides a convenient API for timings.
- 10 StopWatch reports elapsed time between start and stop
- 11 Stop watch with nano second
- 12 Stop Watch with PrintWriter
- 13 Your own timer
Basic Timer
<source lang="java">
import java.util.*; /**
* @author Matthew D. Hicks * */
public class BasicTimer {
public static final int TYPE_CLOCK = 1; public static final int TYPE_ELAPSED = 2; public static final int TYPE_REMAINING = 3; private int type; private long start; private long max; public BasicTimer(int type) { this.type = type; start = System.currentTimeMillis(); } public long getTime() { if (type == TYPE_CLOCK) { return System.currentTimeMillis(); } else if (type == TYPE_ELAPSED) { return System.currentTimeMillis() - start; } else if (type == TYPE_REMAINING) { return max - (System.currentTimeMillis() - start); } throw new RuntimeException("Type does not match anything known: " + type); } public void setMax(long max) { this.max = max; } public static void main(String[] args) throws Exception { int type = TYPE_REMAINING; BasicTimer timer = new BasicTimer(type); timer.setMax(10000); GregorianCalendar calendar = new GregorianCalendar(); while (true) { Thread.sleep(1000); if (type == TYPE_CLOCK) { calendar.setTimeInMillis(timer.getTime()); System.out.println("Clock: " + calendar); } else if (type == TYPE_ELAPSED) { System.out.println("Elapsed: " + (timer.getTime() / 1000) + " seconds"); } else if (type == TYPE_REMAINING) { System.out.println("Remaining: " + (timer.getTime() / 1000) + " seconds"); } } }
}
</source>
Provides the programatic analog of a physical stop watch
<source lang="java">
/* Copyright (c) 2001-2009, The HSQL Development Group
* All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution. * * Neither the name of the HSQL Development Group nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
/**
* Provides the programatic analog of a physical stop watch.
*
* The watch can be started, stopped and zeroed and can be queried for
* elapsed running time. The watch accumulates elapsed time over starts
* and stops such that only the time actually spent running is recorded.
* If the watch is zeroed, then the accumulated time is discarded and
* the watch starts again with zero acumulated time. <p>
*
* @author boucherb@users
* @version 1.7.2
* @since 1.7.2
*/
public class StopWatch {
/**
* The last time this object made the transition
* from stopped to running state, as reported
* by System.currentTimeMillis().
*/
private long startTime;
private long lastStart;
/**
* The accumulated running time of this object since
* it was last zeroed.
*/
private long total;
/** Flags if this object is started or stopped. */
boolean running = false;
/** Creates, zeros, and starts a new StopWatch */
public StopWatch() {
this(true);
}
/** Creates, zeros, and starts a new StopWatch */
public StopWatch(boolean start) {
if (start) {
start();
}
}
/**
* Retrieves the accumulated time this object has spent running since
* it was last zeroed.
* @return the accumulated time this object has spent running since
* it was last zeroed.
*/
public long elapsedTime() {
if (running) {
return total + System.currentTimeMillis() - startTime;
} else {
return total;
}
}
/**
* Retrieves the accumulated time this object has spent running since
* it was last started.
* @return the accumulated time this object has spent running since
* it was last started.
*/
public long currentElapsedTime() {
if (running) {
return System.currentTimeMillis() - startTime;
} else {
return 0;
}
}
/** Zeros accumulated running time and restarts this object. */
public void zero() {
total = 0;
start();
}
/**
* Ensures that this object is in the running state. If this object is not
* running, then the call has the effect of setting the startTime
* attribute to the current value of System.currentTimeMillis() and setting
* the running
attribute to true
.
*/
public void start() {
startTime = System.currentTimeMillis();
running = true;
}
/**
* Ensures that this object is in the stopped state. If this object is
* in the running state, then this has the effect of adding to the
* total
attribute the elapsed time since the last transition
* from stopped to running state and sets the running
attribute
* to false. If this object is not in the running state, this call has no
* effect.
*/
public void stop() {
if (running) {
total += System.currentTimeMillis() - startTime;
running = false;
}
}
public void mark() {
stop();
start();
}
/**
* Retrieves prefix + " in " + elapsedTime() + " ms."
* @param prefix The string to use as a prefix
* @return prefix + " in " + elapsedTime() + " ms."
*/
public String elapsedTimeToMessage(String prefix) {
return prefix + " in " + elapsedTime() + " ms.";
}
/**
* Retrieves prefix + " in " + elapsedTime() + " ms."
* @param prefix The string to use as a prefix
* @return prefix + " in " + elapsedTime() + " ms."
*/
public String currentElapsedTimeToMessage(String prefix) {
return prefix + " in " + currentElapsedTime() + " ms.";
}
/**
* Retrieves the internal state of this object, as a String.
*
* The retreived value is:
*
*
* super.toString() + * "[running=" + * running + * ", startTime=" + * startTime + * ", total=" + * total + "]"; *
* @return the state of this object, as a String */ public String toString() { return super.toString() + "[running=" + running + ", startTime=" + startTime + ", total=" + total + "]"; }
}
</source>
<source lang="java">
//----------------------------------------------------------------------------// // // // C l o c k // // // // Copyright (C) Herve Bitteur 2000-2009. All rights reserved. // // This software is released under the GNU General Public License. // // Please contact users@audiveris.dev.java.net to report bugs & suggestions. // //----------------------------------------------------------------------------// // import java.text.DateFormat; import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.Date; import java.util.Locale; /**
* Class Clock
provides various features related to the current
* date and time, as well as the elapsed time since the beginning of the
* application.
*
* @author Hervé Bitteur
* @version $Id: Clock.java,v 1.8 2009/03/03 19:45:52 hbitteur Exp $
*/
public class Clock {
//~ Static fields/initializers --------------------------------------------- /** To have a reference time */ private static long startTime = System.currentTimeMillis(); /** General date formatting */ private static DateFormat dateFormatter = DateFormat.getDateTimeInstance( DateFormat.FULL, DateFormat.FULL, Locale.US); /** General time formatting. Locale to be used, could be: //Locale.US; //Locale.FRANCE; */ private static Locale locale = Locale.getDefault(); /** Corresponding number format */ private static NumberFormat nf = NumberFormat.getNumberInstance(locale); /** Decimal format */ private static DecimalFormat timeFormatter = (DecimalFormat) nf; static { timeFormatter.applyPattern("000,000.00"); } //~ Constructors ----------------------------------------------------------- //-------// // Clock // To prevent instantiation //-------// private Clock () { } //~ Methods ---------------------------------------------------------------- //---------// // getDate // //---------// /** * Retrieves the values of current date and time of day, and formats a * standard string, * * @return A standardized date + time string */ public static String getDate () { return dateFormatter.format(new Date()); } //------------// // getElapsed // //------------// /** * Retrieves the number of milliseconds since the reference start time, and * formats a standardized string using seconds and milliseconds. NB: The * start time is usually the time when this class was elaborated. It can * also be later reset, via the "reset" method. * * @return A standardized duration string */ public static String getElapsed () { long delta = System.currentTimeMillis() - startTime; return timeFormatter.format((double) delta / 1000); } //-----------// // resetTime // //-----------// /** * Resets the reference start value at the time this method is called. */ public static void resetTime () { startTime = System.currentTimeMillis(); }
}
</source>
Simple stop watch
<source lang="java">
/*
* Copyright 2002-2007 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. */
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 System.currentTimeMillis()
, 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
* @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; /** List of TaskInfo objects */ private final List taskList = new LinkedList(); /** 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 tests run: can"t get last interval"); } return this.lastTaskInfo.getTimeMillis(); } /** * Return the total time in milliseconds for all tasks. */ public long getTotalTimeMillis() { return totalTimeMillis; } /** * Return the total time in seconds for all tasks. */ public double getTotalTimeSeconds() { return totalTimeMillis / 1000.0; } /** * Return the number of tasks timed. */ public int getTaskCount() { return 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 (TaskInfo[]) 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() {
StringBuffer sb = new StringBuffer(shortSummary());
sb.append("\n");
if (!this.keepTaskList) {
sb.append("No task info kept");
}
else {
TaskInfo[] tasks = getTaskInfo();
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 (int i = 0; i < tasks.length; i++) {
sb.append(nf.format(tasks[i].getTimeMillis()) + " ");
sb.append(pf.format(tasks[i].getTimeSeconds() / getTotalTimeSeconds()) + " ");
sb.append(tasks[i].getTaskName() + "\n");
}
}
return sb.toString();
}
/**
* Return an informative string describing all tasks performed
* For custom reporting, call getTaskInfo()
and use the task info directly.
*/
public String toString() {
StringBuffer sb = new StringBuffer(shortSummary());
if (this.keepTaskList) {
TaskInfo[] tasks = getTaskInfo();
for (int i = 0; i < tasks.length; i++) {
sb.append("; [" + tasks[i].getTaskName() + "] took " + tasks[i].getTimeMillis());
long percent = Math.round((100.0 * tasks[i].getTimeSeconds()) / getTotalTimeSeconds());
sb.append(" = " + percent + "%");
}
}
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 class TaskInfo { private final String taskName; private final long timeMillis; private TaskInfo(String taskName, long timeMillis) { this.taskName = taskName; this.timeMillis = timeMillis; } /** * Return the name of this task. */ public String getTaskName() { return taskName; } /** * Return the time in milliseconds this task took. */ public long getTimeMillis() { return timeMillis; } /** * Return the time in seconds this task took. */ public double getTimeSeconds() { return timeMillis / 1000.0; } }
}
</source>
Simulates a stop watch with a lap counter.
<source lang="java">
/*
* JBoss, Home of Professional Open Source * Copyright 2005, JBoss Inc., and individual contributors as indicated * by the @authors tag. See the copyright.txt in the distribution for a * full listing of individual contributors. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */
import java.io.Serializable; /**
* Simulates a stop watch with a lap counter. * * @version $Revision: 2800 $ * @author */
public class StopWatch implements Serializable, Cloneable {
/** The serialVersionUID */ private static final long serialVersionUID = 4628094303187435707L; /** Total time */ protected long total = 0; /** Start time */ protected long start = -1; /** Stop time */ protected long stop = -1; /** The lap count */ protected int count = 0; /** Is the watch started */ protected boolean running = false; /** * Default constructor. */ public StopWatch() { } /** * Construct a StopWatch. * * @param running * Start the watch */ public StopWatch(final boolean running) { if (running) start(); } /** * Start the watch. * * @param reset * True to reset the watch prior to starting. */ public void start(final boolean reset) { if (!running) { if (reset) reset(); start = System.currentTimeMillis(); running = true; } } /** * Start the watch. */ public void start() { start(false); } /** * Stop the watch. * * @return Elapsed time or 0 if the watch was never started. */ public long stop() { long lap = 0; if (running) { count++; stop = System.currentTimeMillis(); lap = stop - start; total += lap; running = false; } return lap; } /** * Reset the watch. */ public void reset() { start = -1; stop = -1; total = 0; count = 0; running = false; } /** * Get the lap count. * * @return The lap count. */ public int getLapCount() { return count; } /** * Get the elapsed lap time since the watch was started. * * @return Elapsed lap time or 0 if the watch was never started */ public long getLapTime() { if (start == -1) { return 0; } else if (running) { return System.currentTimeMillis() - start; } else { return stop - start; } } /** * Get the average lap time since the watch was started. * * @return Average lap time since the watch was started. */ public long getAverageLapTime() { return (count == 0) ? 0 : getLapTime() / getLapCount(); } /** * Get the elapsed time since the watch was created or last reset. * * @return Elapsed time or 0 if the watch was never started. */ public long getTime() { if (start == -1) { return 0; } else if (running) { return total + System.currentTimeMillis() - start; } else { return total; } } /** * Check if the watch is running. * * @return True if the watch is running. */ public boolean isRunning() { return running; } /** * Return a string representation. */ public String toString() { StringBuffer buff = new StringBuffer(); if (running) { // the watch has not been stopped formatElapsedTime(buff, getTime()); // add the current lap time too if there is more than one lap if (count >= 1) { buff.append(", count=").append(count); buff.append(", current="); formatElapsedTime(buff, getLapTime()); } } else { // the watch has been stopped formatElapsedTime(buff, getTime()); // add extra info if there is more than one lap if (count > 1) { buff.append(", count=").append(count); buff.append(", average="); formatElapsedTime(buff, getAverageLapTime()); } } return buff.toString(); } private void formatElapsedTime(final StringBuffer buff, final long lapsed) { long m = lapsed / 60000; if (m != 0) { buff.append(m).append("m:"); } long s = (lapsed - 60000 * m) / 1000; if (s != 0) { buff.append(s).append("s:"); } // ms is always there, even if it was 0 too long ms = (lapsed - 60000 * m - 1000 * s); buff.append(ms).append("ms"); } /** * Return a cloned copy of this object. * * @return A cloned copy of this object. */ public Object clone() { try { return super.clone(); } catch (CloneNotSupportedException e) { throw new InternalError(); } } // /////////////////////////////////////////////////////////////////////// // Wrappers // // /////////////////////////////////////////////////////////////////////// /** * Base wrapper class for other wrappers. */ private static class Wrapper extends StopWatch { /** The serialVersionUID */ private static final long serialVersionUID = 6859401939735540773L; protected StopWatch watch; public Wrapper(final StopWatch watch) { this.watch = watch; } public void start(final boolean reset) { watch.start(reset); } public void start() { watch.start(); } public long stop() { return watch.stop(); } public void reset() { watch.reset(); } public long getLapTime() { return watch.getLapTime(); } public long getAverageLapTime() { return watch.getAverageLapTime(); } public int getLapCount() { return watch.getLapCount(); } public long getTime() { return watch.getTime(); } public boolean isRunning() { return watch.isRunning(); } public String toString() { return watch.toString(); } } /** * Return a synchronized stop watch. * * @param watch * StopWatch to synchronize. * @return Synchronized stop watch. */ public static StopWatch makeSynchronized(final StopWatch watch) { return new Wrapper(watch) { /** The serialVersionUID */ private static final long serialVersionUID = -6284244000894114817L; public synchronized void start(final boolean reset) { this.watch.start(reset); } public synchronized void start() { this.watch.start(); } public synchronized long stop() { return this.watch.stop(); } public synchronized void reset() { this.watch.reset(); } public synchronized long getLapTime() { return this.watch.getLapTime(); } public synchronized long getAverageLapTime() { return this.watch.getAverageLapTime(); } public synchronized int getLapCount() { return this.watch.getLapCount(); } public synchronized long getTime() { return this.watch.getTime(); } public synchronized boolean isRunning() { return this.watch.isRunning(); } public synchronized String toString() { return this.watch.toString(); } }; }
}
</source>
Some simple stop watch.
<source lang="java">
/*
* Copyright 2000,2005 wingS development team. * * This file is part of wingS (http://wingsframework.org). * * wingS is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 * of the License, or (at your option) any later version. * * Please see COPYING for the complete licence. */
import java.text.MessageFormat; import java.util.ArrayList; import java.util.Iterator; /*
* Ein Klasse, die Zeitmessungen aufnimmt und diese in Relation zueineander * setzt. Zum Start der Zeitmessung Methode start kurzer Beschreibung was * gemessen wird als Parameter aufrufen. Das Ende der Zeitmessung wird durch * stop angezeigt. Es kann nur eine Zeitmessung gleichzeitig stattfinden. Die * Ausgabe ist nicht sortiert, gibt aber die relativen Unterschiede in der * Dauer der einzelnen Messungen an. Die Messung mit der laengsten Dauer ist * der Referenzwert (1.0). */
/**
* Some simple stop watch. It allows to measure multiple time periods * and prints them. Usage: call start(comment) and stop() for * each period of time. * * @author */
public class TimeMeasure {
protected final static double RESOLUTION = 100.0; /** * List of measurements. */ protected final ArrayList measures; /** * Message formatter */ protected final MessageFormat formatter; /** * the current time measurement. */ protected Measure current; /** * Simple TimeMesaure with default format. */ public TimeMeasure() { this(new MessageFormat("{0}\t: {1}\t {2}x\n")); } /** * A new TimeMeasure which reports in a specific format. The * format is a standard MessageFormat with the following variables:*
-
*
{0}
the measurement comment
* {1}
the time it took
* {2}
how many times this is faster than the * slowest measurement
*
*/ public TimeMeasure(MessageFormat formatter) { this.measures = new ArrayList(); this.formatter = formatter; } /** * Reset of all Measurements. */ public void reset() { measures.clear(); } /* * Startet eine neue Messsung. * @param comment Die Beschreibung der Messung. */ public void start(String comment) { current = new Measure(comment); } /* * Startet eine neue Messsung. * @param comment Die Beschreibung der Messung. public Object generate(String comment) { current = new Measure(); actual.rument = comment; measures.add(actual); return actual; } */ /* * Addiert eine Messsung zu einer bestehenden. * @param comment Die Beschreibung der Messung. public void addToMeasure(Object measure) { int index = measures.indexOf(measure); if ( index<0 ) { System.err.println("Measure does not exists " + measure); actual = null; return; } actual = (Measure)measures.get(index); measures.remove(index); actual.start = System.currentTimeMillis(); } */ /** * stop current time measurement and store it. */ public void stop() { if (current != null) { current.stop(); measures.add(current); current = null; } } /** * determines the time duration of the longest or shortest time interval. * * @param findShortest boolean "true", if we are looking for the shortest * time interval; "false" if we are looking for the * longest. */ private long findReferenceValue(boolean findShortest) { long result = findShortest ? Long.MAX_VALUE : -1; Iterator it = measures.iterator(); while (it.hasNext()) { Measure m = (Measure) it.next(); result = (findShortest ? Math.min(result, m.getDuration()) : Math.max(result, m.getDuration())); } return result; } public String print() { return print(false); } /** * creates a formatted output (using the MessageFormat) of all * results. The output is sorted in the in the sequence the time * measurements took place. * Writes the relative time to either the shortest or the longest * time interval. * * @param shortestIsReference boolean true, if the shortest time interval * is the reference value (1.0). False, if the * longest is the reference. */ public String print(boolean shortestIsReference) { StringBuilder result = new StringBuilder(); long reference = findReferenceValue(shortestIsReference); Iterator it = measures.iterator(); while (it.hasNext()) { Measure m = (Measure) it.next(); String factor = " -- "; long duration = m.getDuration(); if (reference > 0) { long tmp = (long) ((duration * RESOLUTION) / reference); factor = String.valueOf(tmp / RESOLUTION); } Object[] args = {m.getComment(), (duration + "ms"), factor}; result.append(formatter.format(args)); } return result.toString(); } public String toString() { return print(); } /** * A class to store one period of time. */ private final static class Measure { /** * start time. */ private final long start; /** * stop time. */ private long stop; /** * Die Gesamtdauer der Messung */ private long duration; /** * Description. */ private String comment; public Measure(String comment) { start = System.currentTimeMillis(); this.rument = comment; } public void stop() { stop = System.currentTimeMillis(); duration = stop - start; } public long getDuration() { return duration; } public String getComment() { return comment; } }
}
</source>
Stop Watch from JGraphT
<source lang="java">
/*
* JGraphT : a free Java graph-theory library * * * Project Info: http://jgrapht.sourceforge.net/ * Project Creator: Barak Naveh (http://sourceforge.net/users/barak_naveh) * * (C) Copyright 2003-2007, by Barak Naveh and Contributors. * * This library is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation; either version 2.1 of the License, or * (at your option) any later version. * * This library is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public * License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with this library; if not, write to the Free Software Foundation, * Inc., * 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. */
/* -----------------
* StopWatch.java * ----------------- * (C) Copyright 2005-2007, by Assaf Lehr and Contributors. * * Original Author: Assaf Lehr * Contributor(s): - * * $Id: StopWatch.java 568 2007-09-30 00:12:18Z perfecthash $ * * Changes * ------- */
/**
* @author Assaf * @since May 30, 2005 */
public class StopWatch {
//~ Instance fields -------------------------------------------------------- long beforeTime; //~ Methods ---------------------------------------------------------------- public void start() { this.beforeTime = System.currentTimeMillis(); } public void stopAndReport() { long deltaTime = System.currentTimeMillis() - beforeTime; if (deltaTime > 9999) { double deltaTimeSec = deltaTime / 1000.0; System.out.println( "# Performence: " + deltaTimeSec + " full Seconds"); } else { String timeDesc; timeDesc = (deltaTime <= 10) ? "<10ms [less than minumun measurement time]" : String.valueOf(deltaTime); System.out.println("# Performence: in MiliSeconds:" + timeDesc); } }
} // End StopWatch.java
</source>
Stopwatch is a debugging tool for manually profiling code execution
<source lang="java">
package com.dbxml.util; /*
* dbXML - Native XML Database * Copyright (C) 1999-2004 The dbXML Group, L.L.C. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * $Id: Stopwatch.java,v 1.2 2004/02/12 00:17:58 bradford Exp $ */
/**
* Stopwatch is a debugging tool for manually profiling code execution. * This class will probably be removed for a production release. */
public final class Stopwatch {
private String label; private long total = 0; private long begin = 0; private long end = 0; public Stopwatch() { } public Stopwatch(boolean immediate) { if ( immediate ) start(); } public Stopwatch(String label) { this.label = label; } public Stopwatch(String label, boolean immediate) { this.label = label; if ( immediate ) start(); } public void start() { begin = System.currentTimeMillis(); } public long stop() { end = System.currentTimeMillis(); total += (end - begin); return total; } public void cancel() { begin = 0; end = 0; } public void reset() { total = 0; begin = 0; end = 0; } public long elapsed() { if ( end != 0 ) return end - begin; else return System.currentTimeMillis() - begin; } public long total() { if ( end != 0 ) return total; else return (System.currentTimeMillis() - begin) + total; } public String toString() { return toString(total()); } public String toString(long t) { StringBuffer sb = new StringBuffer(); if ( label != null ) sb.append(label + ": "); long hour = t / 3600000; if ( hour > 0 ) { sb.append(hour + "h "); t = t % 3600000; } long min = t / 60000; if ( min > 0 ) { sb.append(min + "m "); t = t % 60000; } long sec = t / 1000; if ( sec > 0 ) { sb.append(sec + "s "); t = t % 1000; } if ( t > 0 || total() == 0 ) sb.append(t + "ms"); return sb.toString(); }
}
</source>
StopWatch provides a convenient API for timings.
<source lang="java">
import java.util.Date; /*
* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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. */
/**
* <p>
* StopWatch
provides a convenient API for timings.
*
**
* To start the watch, call {@link #start()}. At this point you can: *
*-
*
- {@link #split()} the watch to get the time whilst the watch continues in the background. {@link #unsplit()} will * remove the effect of the split. At this point, these three options are available again. *
- {@link #suspend()} the watch to pause it. {@link #resume()} allows the watch to continue. Any time between the * suspend and resume will not be counted in the total. At this point, these three options are available again. *
- {@link #stop()} the watch to complete the timing session. *
**
* It is intended that the output methods {@link #toString()} and {@link #getTime()} should only be called after stop, * split or suspend, however a suitable result will be returned at other points. *
**
* NOTE: As from v2.1, the methods protect against inappropriate calls. Thus you cannot now call stop before start, * resume before suspend or unsplit before split. *
**
* 1. split(), suspend(), or stop() cannot be invoked twice
* 2. unsplit() may only be called if the watch has been split()
* 3. resume() may only be called if the watch has been suspend()
* 4. start() cannot be called twice without calling reset()
*
* * @author Stephen Colebourne * @since 2.0 * @version $Id: StopWatch.java 583608 2007-10-10 20:38:41Z ggregory $ */
public class StopWatch {
// running states private static final int STATE_UNSTARTED = 0; private static final int STATE_RUNNING = 1; private static final int STATE_STOPPED = 2; private static final int STATE_SUSPENDED = 3; // split state private static final int STATE_UNSPLIT = 10; private static final int STATE_SPLIT = 11; /** * The current running state of the StopWatch. */ private int runningState = STATE_UNSTARTED; /** * Whether the stopwatch has a split time recorded. */ private int splitState = STATE_UNSPLIT; /** * The start time. */ private long startTime = -1; /** * The stop time. */ private long stopTime = -1; /***
* Constructor. *
*/ public StopWatch() { super(); } /***
* Start the stopwatch. *
**
* This method starts a new timing session, clearing any previous values. *
* * @throws IllegalStateException * if the StopWatch is already running. */ public void start() { if (this.runningState == STATE_STOPPED) { throw new IllegalStateException("Stopwatch must be reset before being restarted. "); } if (this.runningState != STATE_UNSTARTED) { throw new IllegalStateException("Stopwatch already started. "); } this.stopTime = -1; this.startTime = System.currentTimeMillis(); this.runningState = STATE_RUNNING; } /***
* Stop the stopwatch. *
**
* This method ends a new timing session, allowing the time to be retrieved. *
* * @throws IllegalStateException * if the StopWatch is not running. */ public void stop() { if (this.runningState != STATE_RUNNING && this.runningState != STATE_SUSPENDED) { throw new IllegalStateException("Stopwatch is not running. "); } if (this.runningState == STATE_RUNNING) { this.stopTime = System.currentTimeMillis(); } this.runningState = STATE_STOPPED; } /***
* Resets the stopwatch. Stops it if need be. *
**
* This method clears the internal values to allow the object to be reused. *
*/ public void reset() { this.runningState = STATE_UNSTARTED; this.splitState = STATE_UNSPLIT; this.startTime = -1; this.stopTime = -1; } /***
* Split the time. *
**
* This method sets the stop time of the watch to allow a time to be extracted. The start time is unaffected, * enabling {@link #unsplit()} to continue the timing from the original start point. *
* * @throws IllegalStateException * if the StopWatch is not running. */ public void split() { if (this.runningState != STATE_RUNNING) { throw new IllegalStateException("Stopwatch is not running. "); } this.stopTime = System.currentTimeMillis(); this.splitState = STATE_SPLIT; } /***
* Remove a split. *
**
* This method clears the stop time. The start time is unaffected, enabling timing from the original start point to * continue. *
* * @throws IllegalStateException * if the StopWatch has not been split. */ public void unsplit() { if (this.splitState != STATE_SPLIT) { throw new IllegalStateException("Stopwatch has not been split. "); } this.stopTime = -1; this.splitState = STATE_UNSPLIT; } /***
* Suspend the stopwatch for later resumption. *
**
* This method suspends the watch until it is resumed. The watch will not include time between the suspend and * resume calls in the total time. *
* * @throws IllegalStateException * if the StopWatch is not currently running. */ public void suspend() { if (this.runningState != STATE_RUNNING) { throw new IllegalStateException("Stopwatch must be running to suspend. "); } this.stopTime = System.currentTimeMillis(); this.runningState = STATE_SUSPENDED; } /***
* Resume the stopwatch after a suspend. *
**
* This method resumes the watch after it was suspended. The watch will not include time between the suspend and * resume calls in the total time. *
* * @throws IllegalStateException * if the StopWatch has not been suspended. */ public void resume() { if (this.runningState != STATE_SUSPENDED) { throw new IllegalStateException("Stopwatch must be suspended to resume. "); } this.startTime += (System.currentTimeMillis() - this.stopTime); this.stopTime = -1; this.runningState = STATE_RUNNING; } /***
* Get the time on the stopwatch. *
**
* This is either the time between the start and the moment this method is called, or the amount of time between * start and stop. *
* * @return the time in milliseconds */ public long getTime() { if (this.runningState == STATE_STOPPED || this.runningState == STATE_SUSPENDED) { return this.stopTime - this.startTime; } else if (this.runningState == STATE_UNSTARTED) { return 0; } else if (this.runningState == STATE_RUNNING) { return System.currentTimeMillis() - this.startTime; } throw new RuntimeException("Illegal running state has occured. "); } /***
* Get the split time on the stopwatch. *
**
* This is the time between start and latest split. *
* * @return the split time in milliseconds * * @throws IllegalStateException * if the StopWatch has not yet been split. * @since 2.1 */ public long getSplitTime() { if (this.splitState != STATE_SPLIT) { throw new IllegalStateException("Stopwatch must be split to get the split time. "); } return this.stopTime - this.startTime; } /** * Returns the time this stopwatch was started. * * @return the time this stopwatch was started * @throws IllegalStateException * if this StopWatch has not been started * @since 2.4 */ public long getStartTime() { if (this.runningState == STATE_UNSTARTED) { throw new IllegalStateException("Stopwatch has not been started"); } return this.startTime; } /***
* Gets a summary of the time that the stopwatch recorded as a string. *
**
* The format used is ISO8601-like, hours:minutes:seconds.milliseconds. *
* * @return the time as a String */ public String toString() { return new Date(getTime()).toString(); } /***
* Gets a summary of the split time that the stopwatch recorded as a string. *
**
* The format used is ISO8601-like, hours:minutes:seconds.milliseconds. *
* * @return the split time as a String * @since 2.1 */ public String toSplitString() { return new Date(getSplitTime()).toString(); }
}
</source>
StopWatch reports elapsed time between start and stop
<source lang="java">
/*
* Copyright 2003-2004 Michael Franken, Zilverline. * * The contents of this file, or the files included with this file, are subject to * the current version of ZILVERLINE Collaborative Source License for the * Zilverline Search Engine (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.zilverline.org. * * See the License for the rights, obligations and * limitations governing use of the contents of the file. * * The Original and Upgraded Code is the Zilverline Search Engine. The developer of * the Original and Upgraded Code is Michael Franken. Michael Franken owns the * copyrights in the portions it created. All Rights Reserved. * */
/**
* StopWatch reports elapsed time between start and stop. * * @author Michael Franken * @version $Revision: 1.12 $ */
public class StopWatch {
/** Time the Stopwatch started. */ private long start = 0; /** Time the Stopwatch stopped. */ private long stop = 0; /** * Start ticking, resets the watch. */ public final void start() { start = System.currentTimeMillis(); } /** * Stop ticking. */ public final void stop() { stop = System.currentTimeMillis(); } /** * Calculates time elapsed. If stop has not been called yet, the current time is taken to calculate elapsed time. * * @return the time elapsed between start and stop as String. The string contains two of days, hours, minutes, seconds and * milliseconds. * * @throws StopWatchException If StopWatch was never started. */ public final String elapsedTime() { long difference; if (stop == 0) { long now = System.currentTimeMillis(); difference = (now - start); // in millis } else { difference = (stop - start); // in millis } long mils = difference % 1000; difference = (difference - mils) / 1000; // in seconds long secs = difference % 60; difference = (difference - secs) / 60; // in minutes long minutes = difference % 60; difference = (difference - minutes) / 60; // in hours long hours = difference % 24; difference = (difference - hours) / 24; // in days long days = difference; String message = ""; if (days > 0) { message = days + " days and " + hours + " hours"; } else if (hours > 0) { message = hours + " hours and " + minutes + " minutes"; } else if (minutes > 0) { message = minutes + " minutes and " + secs + " seconds"; } else if (secs > 0) { message = secs + " seconds and " + mils + " milliseconds"; } else { message = mils + " milliseconds"; } return message; }
}
</source>
Stop watch with nano second
<source lang="java">
public class StopWatch {
public final long t0 = System.currentTimeMillis(); public final long n0 = System.nanoTime(); static public StopWatch start() { return new StopWatch(); }
public long millisEllapsed() { return System.currentTimeMillis() - t0; } public double secondsEllapsed() { return millisEllapsed() / 1000.0; } public long nanoEllapsed() { return System.nanoTime() - n0; }
}
</source>
Stop Watch with PrintWriter
<source lang="java">
import java.io.PrintWriter; /**
* Prints time durations; used for development purposes only.*
* No threads or system resources are harmed in the making of a stop watch. A
* stop watch simply remembers the start time (and elapsed time when paused) and
* prints the total "running" time when either {@link #mark} or
* {@link #stop} is called.
* <p>
* {@link #stop} doesn"t really stop anything. You can call stop as many times
* as you like and it will print the time elapsed since start. It would be easy
* to change this behavior, but I haven"t needed to.
*
* @author Jim Menard,
*/
public class StopWatch {
protected String name;
protected long t0;
protected long elapsedTime;
protected PrintWriter out;
public StopWatch() {
this(null, null);
}
public StopWatch(String name) {
this(name, null);
}
public StopWatch(PrintWriter out) {
this(null, out);
}
public StopWatch(String name, PrintWriter out) {
this.name = name;
if (out == null)
this.out = new PrintWriter(System.err);
else
this.out = out;
elapsedTime = -1L; // So we can tell if we are ever started
}
/**
* Remembers the current time and prints a message.
*/
public void start() {
start(true);
}
/**
* Remembers the current time and prints a message if requested.
*
* @param printStarting
* if true
and this stop watch has a name, print a
* message
*/
public void start(boolean printStarting) {
if (t0 != 0)
System.err.println("(warning: StopWatch already started; resetting)");
if (printStarting && name != null)
System.err.println("starting " + name);
elapsedTime = 0;
t0 = System.currentTimeMillis();
}
/**
* Pauses the stop watch.
*/
public void pause() {
long now = System.currentTimeMillis();
elapsedTime += now - t0;
t0 = 0;
}
/**
* Resumes the stop watch.
*/
public void resume() {
t0 = System.currentTimeMillis();
}
/**
* Prints the current elapsed time without stopping.
*/
public void mark() {
stop(null, true);
}
/**
* Prints the current elapsed time without stopping, along with the stop watch
* name if printMark is true
.
*
* @param printMark
* if true
, the stop watch name will be printed
*/
public void mark(boolean printMark) {
stop(null, printMark);
}
/**
* Prints the current elapsed time without stopping, along with the stop watch
* name and msg.
*
* @param msg
* a message to print
*/
public void mark(String msg) {
stop(msg, true);
}
/**
* Prints the current elapsed time without stopping, along with, along with
* the stop watch name if printMark is true
and the
* msg if it"s not null
.
*
* @param msg
* a message to print
* @param printMark
* if true
, the stop watch name will be printed
*/
public void mark(String msg, boolean printMark) {
stop(msg, printMark);
}
/**
* Stops the stop watch and prints the name of this stop watch and the current
* elapsed time.
*/
public void stop() {
stop(null, true);
}
/**
* Stops the stop watch and prints the name of this stop watch, msg
* if non-null
, and the current elapsed time.
*
* @param msg
* a message to print; may be null
*/
public void stop(String msg) {
stop(msg, true);
}
/**
* Prints the current elapsed time, along with the stop watch name if
* printMark is true
and the msg if
* it"s not null
.
*
* @param msg
* a message to print; may be null
* @param printName
* if true
, the stop watch name will be printed
*/
public void stop(String msg, boolean printName) {
long now = System.currentTimeMillis();
if (elapsedTime == -1) {
System.err.println("(StopWatch" + (name != null ? (" \"" + name + """) : "")
+ " was stopped without ever being started)");
return;
}
long total = elapsedTime;
if (t0 != 0)
total += now - t0;
String separator = null;
if (printName && name != null) {
System.err.print(name);
separator = ": ";
}
if (msg != null) {
if (separator != null)
System.err.print(" ");
System.err.print("(" + msg + ")");
separator = ": ";
}
if (separator != null)
System.err.print(separator);
System.err.println("" + (total / 1000.0) + " seconds");
}
}
</source>
Your own timer
<source lang="java">
/*
* Copyright (c) 1998-2002 Carnegie Mellon University. All rights * reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY CARNEGIE MELLON UNIVERSITY ``AS IS"" AND * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY * NOR ITS EMPLOYEES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * */
import java.util.Vector; public class Timer {
int interval; boolean periodic; boolean isExpired = false; static TimerManager manager = new TimerManager (); long deadline; Timer next, prev; public Timer () { } public void set (int msecDelay, boolean periodic) { interval = msecDelay; this.periodic = periodic; isExpired = false; if (!manager.isAlive ()) { System.err.println ("TimerManager: restarting"); manager = new TimerManager (); } manager.register (this, System.currentTimeMillis () + msecDelay); } public int getInterval () { return interval; } public boolean getPeriodic () { return periodic; } public void cancel () { manager.delete (this); } protected void alarm () { } public boolean expired () { return isExpired; } /* public static void main (String[] args) { for (int i=0; i<args.length; ++i) { boolean periodic = (args[i].charAt (0) == "p"); if (periodic) args[i] = args[i].substring (1); new TestTimer (args[i], Integer.parseInt (args[i]), periodic); } while (true) Thread.yield (); } */
} class TimerManager extends Thread {
Timer first, last; /* static ThreadGroup rootThreadGroup; static { rootThreadGroup = Thread.currentThread().getThreadGroup(); while (rootThreadGroup.getParent() != null) rootThreadGroup = rootThreadGroup.getParent(); } */ public TimerManager () { super (/* rootThreadGroup, */ "Timer Manager"); setDaemon (true); start (); } public synchronized void register (Timer t, long deadline) { t.deadline = deadline; delete (t); // just in case it"s already registered //System.err.println ("TimerManager: set " + t + " to go off at " + deadline); insertion: { for (Timer u = first; u != null; u = u.next) { if (t.deadline < u.deadline) { if (u.prev != null) u.prev.next = t; else first = t; t.prev = u.prev; t.next = u; u.prev = t; break insertion; } } if (last != null) { last.next = t; t.prev = last; t.next = null; last = t; } else { first = last = t; } } //System.err.println ("TimerManager: waking up background thread"); notifyAll (); } public synchronized void delete (Timer t) { if (t.next != null) t.next.prev = t.prev; if (t.prev != null) t.prev.next = t.next; if (t == last) last = t.prev; if (t == first) first = t.next; t.next = null; t.prev = null; } static final int FOREVER = 60000; // wake up at least every 60 seconds public synchronized void run () { while (true) { try { //System.err.println ("TimerManager: awake"); if (first == null) { //System.err.println ("TimerManager: waiting forever"); wait (FOREVER); //System.err.println ("TimerManager: woke up"); } else { Timer t = first; long now = System.currentTimeMillis (); if (t.deadline <= now) { // System.err.println ("TimerManager: timer " + t + " just went off at " + now); try { t.isExpired = true; t.alarm (); } catch (Throwable e) { if (e instanceof ThreadDeath) throw (ThreadDeath)e; else e.printStackTrace (); } if (t.periodic) { register (t, now + t.interval); } else { delete (t); } } else { //System.err.println ("TimerManager: waiting for " + (t.deadline - now) + " msec"); wait (t.deadline - now); //System.err.println ("TimerManager: woke up"); } } } catch (InterruptedException e) {} } }
} /* class TestTimer extends Timer {
String message; public TestTimer (String message, int millisec, boolean periodic) { this.message = message; set (millisec, periodic); } public void alarm () { System.out.println (message); }
}
- /
</source>