Home / Concurrency / Timer tasks to scheduled executors
Concurrency Intermediate

Timer tasks to scheduled executors

Replace Timer and TimerTask with ScheduledExecutorService for robust scheduled work.

Concurrency
Code Comparison
✕ Timer and TimerTask 
Timer timer = new Timer("refresh-timer");
timer.scheduleAtFixedRate(new TimerTask() {
    @Override
    public void run() {
        refresh();
    }
}, 0, 60_000);
✓ ScheduledExecutorService 
ScheduledExecutorService scheduler =
        Executors.newScheduledThreadPool(2);

scheduler.scheduleAtFixedRate(
        this::refresh, 0, 1, TimeUnit.MINUTES);
See a problem with this code? Let us know.
Why the modern way wins
🧵

Better isolation

A configurable thread pool prevents unrelated schedules from sharing one fragile worker.

🛡

Robust execution

One failing task does not terminate the scheduler itself.

🎛

Controllable lifecycle

Futures, cancellation, delays, and shutdown use standard executor APIs.

Old Approach
Timer and TimerTask
Modern Approach
ScheduledExecutorService
Since JDK
5
Difficulty
Intermediate
JDK Support
Timer tasks to scheduled executors
Available

Widely available since JDK 5 (Sept 2004)

How it works

Timer executes every task on one thread, so one long-running task delays the others, and an unchecked exception terminates the timer thread. ScheduledExecutorService uses the executor framework, supports multiple workers, returns ScheduledFuture handles, and provides explicit lifecycle management. The owning component must shut the scheduler down when it is no longer needed.

Related Documentation
ScheduledExecutorService ↗ Executors ↗
Proof
View proof source ↗
Related patterns
Concurrency Beginner

ExecutorService auto-close

Java 8
ExecutorService exec =
    Executors.newCachedThreadPool();
try {
    exec.submit(task);
} finally {
    exec.shutdown();
    exec.awaitTermination(
        1, TimeUnit.MINUTES);
}
Java 19+
try (var exec =
        Executors.newCachedThreadPool()) {
    exec.submit(task);
}
// auto shutdown + await on close
Hover to see modern ➜
JDK 19+ →
Concurrency Beginner

Thread.sleep with Duration

Java 8
// What unit is 5000? ms? us?
Thread.sleep(5000);

// 2.5 seconds: math required
Thread.sleep(2500);
Java 19+
Thread.sleep(
    Duration.ofSeconds(5)
);
Thread.sleep(
    Duration.ofMillis(2500)
);
Hover to see modern ➜
JDK 19+ →
Concurrency Advanced

Structured concurrency

Java 8
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
Java 25 (Preview)
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
Hover to see modern ➜
JDK 25+ →