In this example, the main program waits for a second (with Thread.sleep()) while the tasks is scheduled, so we will see the output running, and after that second, the process stops, but not exits because the Timer is still active. We can write “timer.cancel()”, the task is cancelling too and the program exists.

The problem comes when resumin this task after a while, because we have to create the TimerTask object again, if we try to reuse the old TimerTask (task) created, we’ll get an exception.

But, as we must define the inner TimerTask class again, it’s interesting to create a separate derivate class. But let’s go further, we’ll make a TimerTask derivate that cancels and resumes itself, so our TimerTask (MyTimerTask) must know the Timer object, this way it can also re-schedule the task at different frequencies:

But, as we can see, we must re-create the task object when re-scheduling, what about passing information between the old task to the new task? We may want that, for example, to know what has happened before the new task is created. To do that, we can create a store class, where we can use the attributes to store useful information between schedules, and we can pass this variable to our MyTimerTask constructor, but to avoid external classes to modify the values of our store class, this new overloaded constructor can be private.

In the next example, we just store an integer (we can store as many things as we want), and with this object we will control the times the task was canceled, and make it exit after 5 times:
MyTimerTaskInfo.java

I recently talked about using TimerTask in Java. Today we will pass variables or attributes to that TimerTask. We saw in the last article variable passing to an implicit or inner class, but now we’re creating a subclass and passing arguments through the constructor.

In this example, we’ve passed two arguments: 10, “Start: “, to the TimerTask (MyTimerTask) constructor, they will be the number of times the task must be launched before writing “TEN! ” on a String. On the other hand, we’ve implemented the method toString in MyTimerTask to write the value directly with System.out.println().

Easy, but, what about passing a callback to execute the System.out.println() ¿?

Let’s write an interface for the Callback (MyTimerCallback), then we will implement MyTimerTask and then we will make TimerEx implement MyTimerCallback, so we can put this function in the main class:

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).

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:

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