Thread In Java Technology

Task Scheduling

Code: reminder.java

import java.util.Timer;
import java.util.TimerTask;

/**
* Simple demo that uses java.util.Timer to schedule a task
* to execute once 5 seconds have passed.
*/

public class Reminder {
    Timer timer;

    public Reminder(int seconds) {
        timer = new Timer();
        timer.schedule(new RemindTask(), seconds*1000);
}

    class RemindTask extends TimerTask {
        public void run() {
            System.out.println("Time's up!");
            timer.cancel(); //Terminate the timer thread
        }
    }

    public static void main(String args[]) {
        new Reminder(5);
        System.out.println("Task scheduled.");
    }
}

Stopping Timer Threads
There are four ways that you can stop a timer:

• Invoke cancel on the timer. You can do this from anywhere in the program, such as from a timer task抯 run method.
• Make the timer抯 thread a 揹aemon? by creating the timer like this: new Timer(true). If the only threads left in the program are daemon threads, the program exits.
• After all the timer抯 scheduled tasks have finished executing, remove all references to the Timer object. Eventually, the timer抯 thread will terminate.
• Invoke the System.exit method, which makes the entire program (and all its threads) exit.
  
  Performing a Task Repeatedly
  This can be accomplished by changing a different timer.schedule(); Here are all the schedule APIs that can be used to performe a task repeatedly
• schedule(TimerTask task, long delay, long period)
• schedule(TimerTask task, Date time, long period)
• scheduleAtFixedRate(TimerTask task, long delay, long period)
• scheduleAtFixedRate(TimerTask task, Date firstTime, long period)
  
  
  Implementing the Runnable Interface
  
  You have now seen two ways to provide the run method.
  • Subclass the Thread class and override the run method. See the SimpleThread class described in the section Subclassing Thread and Overriding run.
  • Provide a class that implements the Runnable interface and therefore implements the run method. In this case, a Runnable object provides the run method to the thread. See the Clock applet in the preceding section.

  There are good reasons for choosing either of these options over the other. However, for most cases, including that of the Clock applet, if your class must subclass some other class (the most common example being Applet), you should use Runnable.

  import java.awt.Graphics;
  import java.util.*;
  import java.text.DateFormat;
  import java.applet.Applet;
  
  public class Clock extends Applet implements Runnable {
      private Thread clockThread = null;
      public void start() {
          if (clockThread == null) {
              clockThread = new Thread(this, "Clock");
              clockThread.start();
          }
      }
      public void run() {
          Thread myThread = Thread.currentThread();
          while (clockThread == myThread) {
              repaint();
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  //the VM doesn抰 want us to sleep anymore,
                  //so get back to work
              }
          }
      }
      public void paint(Graphics g) {
          //get the time and convert it to a date
          Calendar cal = Calendar.getInstance();
          Date date = cal.getTime();
          //format it and display it
          DateFormat dateFormatter =
  				DateFormat.getTimeInstance();
          g.drawString(dateFormatter.format(date), 5, 10);
      }
      //overrides Applet抯 stop method, not Thread抯
      public void stop() {
          clockThread = null;
      }
  }