Running a Java Thread in intervals

Question

I have a thread that needs to be executed every 10 seconds. This thread contains several calls (12 - 15) to a database on another server. Additionally, it also accesses around 3 files. Consequently, there will be quite a lot of IO and network overhead.

What is the best strategy to perform the above?

One way would be to use the sleep method along with a while loop, but that would be a bad design.

Will a class similar to Timer be helpful in this case? Also, would it be better to create a couple of more threads (one for IO and one for JDBC), instead of having them run in one thread?

Answer 1

I find that a ScheduledExecutorService is an excellent way to do this. It is arguably slightly more complex than a Timer, but gives more flexibility in exchange (e.g. you could choose to use a single thread or a thread pool; it takes units other than solely milliseconds).

ScheduledExecutorService executor =
    Executors.newSingleThreadScheduledExecutor();

Runnable periodicTask = new Runnable() {
    public void run() {
        // Invoke method(s) to do the work
        doPeriodicWork();
    }
};

executor.scheduleAtFixedRate(periodicTask, 0, 10, TimeUnit.SECONDS);

Answer 2

Have a look at the Timer and TimerTask classes. They are exactly what you want.

You can make a TimerTask implementation that takes your thread object in a constructor.

The run method will then call the threads run method.

// Perhaps something like this
Timer t = new Timer();
t.scheduleAtFixedRate(yourTimerTask, 0, 10 * 1000);
// Hopefully your task takes less than 12 seconds

Answer 3

One option is to create a ScheduledExecutorService to which you can then schedule your job:

ScheduledExecutorService ex = Executors.newSingleThreadScheduledExecutor();
ex.scheduleWithFixedDelay(...);

If you did decide to have multiple threads, then you can create a ScheduledExecutorService with more threads (again, via the Executors class).

In terms of how many threads and what you put in each thread, in terms of performance, I'd say this depends on:

• for your particular application, can one thread genuinely "do work" while another one is waiting for I/O?
• would your multiple threads ultimately "thrash the same resource" (e.g. read from files in different locations on the same dsk) and thus slow one another down, or would they be simultaneously hitting different resources?