Java Tutorial/Development/Timer

Class encapsulating timer functionality

   <source lang="java">

/*

* Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
* 
* Project: OpenSubsystems
* 
* $Id: MyTimer.java,v 1.5 2007/01/07 06:14:00 bastafidli Exp $
* 
* 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; version 2 of the License. 
* 
* 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 
*/

/**

* Class encapsulating timer functionality.
* 
* @version $Id: MyTimer.java,v 1.5 2007/01/07 06:14:00 bastafidli Exp $
* @author Miro Halas
* @code.reviewer Miro Halas
* @code.reviewed Initial revision
*/

public class MyTimer {

  // Attributes ///////////////////////////////////////////////////////////////
  
  /**
   * Remeber start time here.
   */
  private long m_lStartTime;
  
  /**
   * Remeber stop time here.
   */
  private long m_lStopTime;
  // Constructors /////////////////////////////////////////////////////////////
  
  /**
   * Default constructor.
   * Starts counting fro the moment it is cosntructed.
   */
  public MyTimer(
  )
  {
     reset();
  }
  // Logic ////////////////////////////////////////////////////////////////////
  
  /**
   * @return long - start time;
   */
  public long getStartTime()
  {
     return m_lStartTime;
  }
  /**
   * @return - stop time;
   */
  public long getStopTime()
  {
     return m_lStopTime;
  }
  /**
   * Reset the counter and start counting from scratch.
   */
  public void reset(
  )
  {
     m_lStartTime = System.currentTimeMillis();
     m_lStopTime = 0;
  }
  /**
   * Stop the timer.
   */
  public void stop(
  )
  {
     m_lStopTime = System.currentTimeMillis();
  }
  /**
   * Get timer duration (the timer doesn"t stop) in milliseconds.
   * 
   * @return long - difference between stop and start time.
   */
  public long getDuration(
  )
  {
     long lStopTime;
     if (m_lStopTime == 0)
     {
        lStopTime = System.currentTimeMillis();
     }
     else
     {
        lStopTime = m_lStopTime;
     }
     return lStopTime - m_lStartTime;
  }
  /**
   * Print the state of the timer without stopping it.
   * @return String - timing information
   */
  public String toString(
  )
  {
     long lTotalMS   = getDuration();
     long lMS        = lTotalMS % 1000;
     long lTotalSecs = lTotalMS / 1000;
     long lSecs      = lTotalSecs % 60;
     long lTotalMins = lTotalSecs / 60;
     long lMinutes   = lTotalMins % 60;
     long lHours     = lTotalMins / 60;
     StringBuffer sbBuffer = new StringBuffer();
     if (lHours > 0)
     {
        sbBuffer.append(lHours);
        sbBuffer.append(":");
        sbBuffer.append(lMinutes);
        sbBuffer.append(":");
        sbBuffer.append(lSecs);
        sbBuffer.append(".");
        sbBuffer.append(lMS);
     }
     else if (lMinutes > 0)
     {
        sbBuffer.append(lMinutes);
        sbBuffer.append(":");
        sbBuffer.append(lSecs);
        sbBuffer.append(".");
        sbBuffer.append(lMS);
     }
     else if (lSecs > 0)
     {
        sbBuffer.append(lSecs);
        sbBuffer.append(".");
        sbBuffer.append(lMS);
        sbBuffer.append(" seconds");
     }
     else
     {
        sbBuffer.append(lMS);
        sbBuffer.append(" ms");
     }
     
     return sbBuffer.toString();
  }

}</source>

Create a scheduled task using timer

   <source lang="java">

import java.text.DateFormat; import java.text.SimpleDateFormat; import java.util.Date; import java.util.Timer; import java.util.TimerTask; public class Main extends TimerTask {

 private DateFormat formatter = new SimpleDateFormat("hh:mm:ss a");
 public static void main(String[] args) {
   TimerTask task = new Main();
   Timer timer = new Timer();
   timer.scheduleAtFixedRate(task, new Date(), 1000);
 }
 public void run() {
   System.out.println(formatter.format(new Date()));
 }

}</source>

Create a Timer object

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; public class Main {

 Timer timer;
 public Main(int seconds) {
   timer = new Timer();
   timer.schedule(new ToDoTask(), seconds * 1000);
 }
 class ToDoTask extends TimerTask {
   public void run() {
     System.out.println("working");
     timer.cancel(); 
   }
 }
 public static void main(String args[]) {
   new Main(5);
 }

}</source>

Demonstrate Timer and TimerTask.

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; class MyTimerTask extends TimerTask {

 public void run() {
   System.out.println("Timer task executed.");
 }

} class TTest {

 public static void main(String args[]) {
   MyTimerTask myTask = new MyTimerTask();
   Timer myTimer = new Timer();
   myTimer.schedule(myTask, 1000, 500);
   try {
     Thread.sleep(5000);
   } catch (InterruptedException exc) {
   }
   myTimer.cancel();
 }

}</source>

extends TimerTask to create your own task

   <source lang="java">

import java.io.DataOutputStream; import java.io.IOException; import java.io.OutputStream; import java.util.TimerTask; class MyTask extends TimerTask {

 private DataOutputStream out;
 public MyTask(OutputStream dest) {
   out = new DataOutputStream(dest);
 }
 public void run() {
   try {
     out.writeInt(1);
     out.writeUTF("asdf");
   } catch (IOException e) {
     e.printStackTrace();
   }
 }

}</source>

Pause and start a timer task

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; class MyTask extends TimerTask {

 int counter;
 public MyTask() {
   counter = 0;
 }
 public void run() {
   counter++;
   System.out.println("Ring " + counter);
 }
 public int getCount() {
   return counter;
 }

} public class Main {

 private boolean running;
 private MyTask task;
 private Timer timer;
 public Main() {
   timer = new Timer(true);
 }
 public boolean isRinging() {
   return running;
 }
 public void startRinging() {
   running = true;
   task = new MyTask();
   timer.scheduleAtFixedRate(task, 0, 3000);
 }
 public void doIt() {
   running = false;
   System.out.println(task.getCount() + " times");
   task.cancel();
 }
 public static void main(String[] args) {
   Main phone = new Main();
   phone.startRinging();
   try {
     System.out.println("started running...");
     Thread.sleep(20000);
   } catch (InterruptedException e) {
   }
   phone.doIt();
 }

}</source>

Schedule a task by using Timer and TimerTask.

   <source lang="java">

import java.util.Date; import java.util.Timer; import java.util.TimerTask; class AutoTask extends TimerTask {

 AutoTask() {
 }
 public void run() {
   System.out.println(new Date());
 }

} public class Main {

 public static void main(String args[]) {
   AutoTask myTask = new AutoTask();
   Timer bkTimer = new Timer();
   bkTimer.schedule(myTask, 2000, 2000);
   for (int i = 0; i < 5; i++) {
     try {
       Thread.sleep(2100);
     } catch (InterruptedException exc) {
     }
   }
   bkTimer.cancel();
 }

}</source>

Scheduling a Timer Task to Run Repeatedly

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; public class Main {

 public static void main(String[] argv) throws Exception {
   int delay = 5000; // delay for 5 sec.
   int period = 1000; // repeat every sec.
   Timer timer = new Timer();
   timer.scheduleAtFixedRate(new TimerTask() {
     public void run() {
       System.out.println("doing"); 
     }
   }, delay, period);
 }

}</source>

Swing also provide a Timer class. A Timer object will send an ActionEvent to the registered ActionListener.

   <source lang="java">

import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.Timer; public class Main implements ActionListener {

 Timer t = new Timer(1000, this);
 Main() {
   t.start();
 }
 public void actionPerformed(ActionEvent e) {
   System.out.println("working");
 }
 public static void main(String args[]) {
   Main main = new Main();
 }

}</source>

Timer and TimerTask Classes

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; class GCTask extends TimerTask {

 public void run() {
   System.out.println("Running the scheduled task...");
   System.gc();
 }

} public class Main {

 public static void main(String[] args) {
   Timer timer = new Timer();
   GCTask task = new GCTask();
   timer.schedule(task, 5000, 5000);
   int counter = 1;
   while (true) {
     try {
       Thread.sleep(500);
     } catch (InterruptedException e) {
     }
   }
 }

}</source>

Using Timers

The java.util.Timer class provides an alternative way to perform scheduled or recurrent tasks.

   <source lang="java">

import java.util.Timer; import java.util.TimerTask; public class MainClass {

 public static void main(String[] args) {
   Timer timer = new Timer();
   timer.schedule(new DisplayQuestionTask(), 0, 10 * 1000);
   try {
     Thread.sleep(10000);
   } catch (InterruptedException e) {
   }
   
   timer.cancel();
   
   
 }

} class DisplayQuestionTask extends TimerTask {

 int counter = 0;
 public void run() {
   System.out.println(counter++);
 }

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