Home > Java > Introduction to Timer and TimerTask in Java

Introduction to Timer and TimerTask in Java

Timers are a useful tool to launch a task periodically, for example, if we are connected to a server, we can send status information to avoid disconnections, or launch a cron task, or even to run an animation (as the time goes by, we are changing a draw or a frame).

The most easy example can be:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import java.util.Timer;
import java.util.TimerTask;

class TimerEx {
    public static void main(String arglist[]) {
    Timer timer;
    timer = new Timer();

    TimerTask task = new TimerTask() {
        int tic=0;

        @Override
        public void run()
        {
            if (tic%2==0)
            System.out.println("TIC");
            else
            System.out.println("TOC");
            tic++;
        }
        };
        // Start in 10ms and then, launch the task each 1000ms
    timer.schedule(task, 10, 1000);
    }
}

This program writes TIC and TOC alternatively each second, as the task is programmed each 1000ms. Is extremely easy, first, we must create a TimerTask object defining the task we want to launch inside the run() method (which we must @Override). Then, load a Timer and running the method schedule() we can call the desired task defining the time we want to wait before launching the first time and then the time we must wait before launching again the task.

If we only give one argument, the task will execute just once in N milliseconds. We can also specify Date objects in these arguments.

We can also call another schedule method called scheduleAtFixedRate, the difference is noticed when there are delays in executions (the tasks may be delayed due to other things in execution, instead of running each 1000ms, one task may be launched in 1500ms (because of these delays), scheduleAtFixedRate() will try to run the next task in 500ms to compensate lost time, but schedule() will run it after 1000ms, no matter if the task before was delayed.

The TimerTask in the example was created implicitly, it was an inner class, it’s absolutely valid for an example, or simple tasks. If we have something bigger it’s recommended to create a separate class for this task extending TimerTask superclass.

But, now the question is, how can we call an external variable? (External to the inner TimerTask we’ve created), call a variable of the main method of TimerEx. It has nothing to do with Timers but it’s interesting to tell:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Timer;
import java.util.TimerTask;

class TimerEx {
    public static void main(String arglist[]) {
    Timer timer;
    timer = new Timer();
    final String str = new String("REACHED TEN TICS");

    TimerTask task = new TimerTask() {
        int tic = 0;

        @Override
        public void run()
        {
            if (tic%2==0)
            System.out.println("TIC");
            else
            System.out.println("TOC");
            tic++;
            if (tic%10==0)
            {
                System.out.println(str);
            }
        }
        };

    timer.schedule(task, 0, 1000);
    }
}

In this example, we’ve called the task ten times, and then str String will be written on screen. So inside inner or nested classes we can access final variables. But we can’t write them, because they are final. There is an scape, we can create a class allowing us to modify it’s attributes, so the value we are interested in can be changed. Let’s create a class TicClass to get tic attribute out of the nested TimerTask

TicClass.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class TicClass
{
    private int value;

    public TicClass(int initialValue)
    {
    this.value=initialValue;
    }

    public TicClass()
    {
    this.value=0;
    }

    public void setValue(int newValue)
    {
    this.value=newValue;
    }

    public int getValue()
    {
    return this.value;
    }

    public void increment()
    {
    this.value++;
    }
}

TimerEx.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
import java.util.Timer;
import java.util.TimerTask;

class TimerEx {
    public static void main(String arglist[]) {
    Timer timer;
    timer = new Timer();
    final TicClass tic;
    tic = new TicClass(5);

    TimerTask task = new TimerTask() {
        @Override
        public void run()
        {
            if (tic.getValue()%2==0)
            System.out.println("TIC");
            else
            System.out.println("TOC");

            tic.increment();

            if (tic.getValue()%10==0)
            {
                System.out.println("TEN TICS!");
            }
        }
        };

    timer.schedule(task, 10, 1000);
    }
}

With this idea we can try to create a collection class to get some objects we want to change within the TimerTask and pass it as a final variable to the implicit class.

Photo: Andy Roberts (Flickr) CC-by

Top