Java/Development Class/StopWatch

Материал из Java эксперт
Перейти к: навигация, поиск

Basic Timer

 

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");
      }
    }
  }
}





Provides the programatic analog of a physical stop watch

 
/* 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. <p>
 *
 * 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 <code>startTime</code>
     * attribute to the current value of System.currentTimeMillis() and setting
     * the <code>running</code> attribute to <code>true</code>.
     */
    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
     * <code>total</code> attribute the elapsed time since the last transition
     * from stopped to running state and sets the <code>running</code> 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:
     *
     * <pre>
     *    super.toString() +
     *    "[running=" +
     *    running +
     *    ", startTime=" +
     *    startTime +
     *    ", total=" +
     *    total + "]";
     * </pre>
     * @return the state of this object, as a String
     */
    public String toString() {
        return super.toString() + "[running=" + running + ", startTime="
               + startTime + ", total=" + total + "]";
    }
}





Provides various features related to the current date and time

 
//----------------------------------------------------------------------------//
//                                                                            //
//                                 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 <code>Clock</code> provides various features related to the current
 * date and time, as well as the elapsed time since the beginning of the
 * application.
 *
 * @author Herv&eacute; 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();
    }
}





Simple stop watch

 
/*
 * 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 <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
 * @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 <code>getTaskInfo()</code> 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;
    }
  }
}





Simulates a stop watch with a lap counter.

 
/*
 * 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 <em>lap</em> counter.
 * 
 * @version <tt>$Revision: 2800 $</tt>
 * @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 <i>lap</i> 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 <i>lap</i> count.
   * 
   * @return The <i>lap</i> count.
   */
  public int getLapCount() {
    return count;
  }
  /**
   * Get the elapsed <i>lap</i> time since the watch was started.
   * 
   * @return Elapsed <i>lap</i> 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 <i>lap</i> time since the watch was started.
   * 
   * @return Average <i>lap</i> 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();
      }
    };
  }
}





Some simple stop watch.

 
/*
 * 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:
     * <ul>
     * <li><code>{0}</code> the measurement comment</li>
     * <li><code>{1}</code> the time it took</li>
     * <li><code>{2}</code> how many times this is faster than the
     * slowest measurement</li>
     * </ul>
     */
    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; }
    }
}





Stop Watch from JGraphT

 
/* 
 * 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





Stopwatch is a debugging tool for manually profiling code execution

 
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();
   }
}





StopWatch provides a convenient API for timings.

 
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>
 * <code>StopWatch</code> provides a convenient API for timings.
 * </p>
 * 
 * <p>
 * To start the watch, call {@link #start()}. At this point you can:
 * </p>
 * <ul>
 * <li>{@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.</li>
 * <li>{@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.</li>
 * <li>{@link #stop()} the watch to complete the timing session.</li>
 * </ul>
 * 
 * <p>
 * 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.
 * </p>
 * 
 * <p>
 * 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.
 * </p>
 * 
 * <p>
 * 1. split(), suspend(), or stop() cannot be invoked twice<br />
 * 2. unsplit() may only be called if the watch has been split()<br />
 * 3. resume() may only be called if the watch has been suspend()<br />
 * 4. start() cannot be called twice without calling reset()
 * </p>
 * 
 * @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;
    /**
     * <p>
     * Constructor.
     * </p>
     */
    public StopWatch() {
        super();
    }
    /**
     * <p>
     * Start the stopwatch.
     * </p>
     * 
     * <p>
     * This method starts a new timing session, clearing any previous values.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Stop the stopwatch.
     * </p>
     * 
     * <p>
     * This method ends a new timing session, allowing the time to be retrieved.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Resets the stopwatch. Stops it if need be.
     * </p>
     * 
     * <p>
     * This method clears the internal values to allow the object to be reused.
     * </p>
     */
    public void reset() {
        this.runningState = STATE_UNSTARTED;
        this.splitState = STATE_UNSPLIT;
        this.startTime = -1;
        this.stopTime = -1;
    }
    /**
     * <p>
     * Split the time.
     * </p>
     * 
     * <p>
     * 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.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Remove a split.
     * </p>
     * 
     * <p>
     * This method clears the stop time. The start time is unaffected, enabling timing from the original start point to
     * continue.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Suspend the stopwatch for later resumption.
     * </p>
     * 
     * <p>
     * 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.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Resume the stopwatch after a suspend.
     * </p>
     * 
     * <p>
     * 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.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Get the time on the stopwatch.
     * </p>
     * 
     * <p>
     * This is either the time between the start and the moment this method is called, or the amount of time between
     * start and stop.
     * </p>
     * 
     * @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. ");
    }
    /**
     * <p>
     * Get the split time on the stopwatch.
     * </p>
     * 
     * <p>
     * This is the time between start and latest split.
     * </p>
     * 
     * @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;
    }
    /**
     * <p>
     * Gets a summary of the time that the stopwatch recorded as a string.
     * </p>
     * 
     * <p>
     * The format used is ISO8601-like, <i>hours</i>:<i>minutes</i>:<i>seconds</i>.<i>milliseconds</i>.
     * </p>
     * 
     * @return the time as a String
     */
    public String toString() {
        return new Date(getTime()).toString();
    }
    /**
     * <p>
     * Gets a summary of the split time that the stopwatch recorded as a string.
     * </p>
     * 
     * <p>
     * The format used is ISO8601-like, <i>hours</i>:<i>minutes</i>:<i>seconds</i>.<i>milliseconds</i>.
     * </p>
     * 
     * @return the split time as a String
     * @since 2.1
     */
    public String toSplitString() {
        return new Date(getSplitTime()).toString();
    }
}





StopWatch reports elapsed time between start and stop

 
/*
 * 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;
    }
}





Stop watch with nano second

 
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;
  }
}





Stop Watch with PrintWriter

 
import java.io.PrintWriter;
/**
 * Prints time durations; used for development purposes only.
 * <p>
 * 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 &quot;running&quot; 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 <code>true</code> 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 <var>printMark</var> is <code>true</code>.
   * 
   * @param printMark
   *          if <code>true</code>, 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 <var>msg</var>.
   * 
   * @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 <var>printMark</var> is <code>true</code> and the
   * <var>msg</var> if it"s not <code>null</code>.
   * 
   * @param msg
   *          a message to print
   * @param printMark
   *          if <code>true</code>, 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, <var>msg</var>
   * if non-<code>null</code>, and the current elapsed time.
   * 
   * @param msg
   *          a message to print; may be <code>null</code>
   */
  public void stop(String msg) {
    stop(msg, true);
  }
  /**
   * Prints the current elapsed time, along with the stop watch name if
   * <var>printMark</var> is <code>true</code> and the <var>msg</var> if
   * it"s not <code>null</code>.
   * 
   * @param msg
   *          a message to print; may be <code>null</code>
   * @param printName
   *          if <code>true</code>, 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");
  }
}





Your own timer

 
/*
 * 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);
    }
}
*/