I have code where I schedule a task using java.util.Timer
. I was looking around and saw ExecutorService
can do the same. So this question here, have you used Timer
and ExecutorService
to schedule tasks, what is the benefit of one using over another?
Also wanted to check if anyone had used the Timer
class and ran into any issues which the ExecutorService
solved for them.
On the other hand, ExecutorService is an extension of the Executor interface and provides a facility for returning a Future object and terminate, or shut down the thread pool. Once the shutdown is called, the thread pool will not accept new tasks but complete any pending task.
The ExecutorService helps in maintaining a pool of threads and assigns them tasks. It also provides the facility to queue up tasks until there is a free thread available if the number of tasks is more than the threads available.
Timer and TimerTask are java util classes that we use to schedule tasks in a background thread. Basically, TimerTask is the task to perform, and Timer is the scheduler.
ExecutorService does not mandate or otherwise guarantee that all implementations are thread-safe, and it cannot as it is an interface. These types of contracts are outside of the scope of a Java interface. However, ThreadPoolExecutor both is and is clearly documented as being thread-safe.
According to Java Concurrency in Practice:
Timer
can be sensitive to changes in the system clock, ScheduledThreadPoolExecutor
isn't.Timer
has only one execution thread, so long-running task can delay other tasks. ScheduledThreadPoolExecutor
can be configured with any number of threads. Furthermore, you have full control over created threads, if you want (by providing ThreadFactory
).TimerTask
kill that one thread, thus making Timer
dead :-( ... i.e. scheduled tasks will not run anymore. ScheduledThreadExecutor
not only catches runtime exceptions, but it lets you handle them if you want (by overriding afterExecute
method from ThreadPoolExecutor
). Task which threw exception will be canceled, but other tasks will continue to run.If you can use ScheduledThreadExecutor
instead of Timer
, do so.
One more thing... while ScheduledThreadExecutor
isn't available in Java 1.4 library, there is a Backport of JSR 166 (java.util.concurrent
) to Java 1.2, 1.3, 1.4, which has the ScheduledThreadExecutor
class.
If it's available to you, then it's difficult to think of a reason not to use the Java 5 executor framework. Calling:
ScheduledExecutorService ex = Executors.newSingleThreadScheduledExecutor();
will give you a ScheduledExecutorService
with similar functionality to Timer
(i.e. it will be single-threaded) but whose access may be slightly more scalable (under the hood, it uses concurrent structures rather than complete synchronization as with the Timer
class). Using a ScheduledExecutorService
also gives you advantages such as:
newScheduledThreadPoolExecutor()
or the ScheduledThreadPoolExecutor
class)About the only reasons for sticking to Timer
I can think of are:
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With