Startseite / Concurrency / Von Timer und TimerTask zu ScheduledExecutorService
Concurrency Fortgeschritten

Von Timer und TimerTask zu ScheduledExecutorService

Timer und TimerTask durch ScheduledExecutorService für robuste Aufgabenplanung ersetzen.

Concurrency
Code-Vergleich
✕ 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);
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
🧵

Bessere Isolation

Ein konfigurierbarer Thread-Pool verhindert, dass sich unabhängige Zeitpläne einen fragilen Worker teilen.

🛡

Robuste Ausführung

Eine fehlschlagende Aufgabe beendet nicht den Scheduler selbst.

🎛

Steuerbarer Lebenszyklus

Futures, Abbruch, Verzögerungen und Herunterfahren nutzen Standard-Executor-APIs.

Alter Ansatz
Timer und TimerTask
Moderner Ansatz
ScheduledExecutorService
Seit JDK
5
Schwierigkeitsgrad
Fortgeschritten
JDK-Unterstützung
Von Timer und TimerTask zu ScheduledExecutorService
Verfügbar

Weithin verfügbar seit JDK 5 (Sept. 2004)

Wie es funktioniert

Timer führt jede Aufgabe auf einem Thread aus, sodass eine lang laufende Aufgabe die anderen verzögert und eine unbehandelte Ausnahme den Timer-Thread beendet. ScheduledExecutorService nutzt das Executor-Framework, unterstützt mehrere Worker, liefert ScheduledFuture-Handles und bietet ein explizites Lifecycle-Management. Die besitzende Komponente muss den Scheduler herunterfahren, wenn er nicht mehr benötigt wird.

Zugehörige Dokumentation
ScheduledExecutorService ↗ Executors ↗
Beweis
Beweisquelle ansehen ↗
Verwandte Muster
Concurrency Einsteiger

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 für Modernes ➜
JDK 19+ →
Concurrency Einsteiger

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 für Modernes ➜
JDK 19+ →
Concurrency Experte

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 für Modernes ➜
JDK 25+ →