Accueil / Concurrency / Des tâches Timer aux exécuteurs planifiés
Concurrency Intermédiaire

Des tâches Timer aux exécuteurs planifiés

Remplacez Timer et TimerTask par ScheduledExecutorService pour un travail planifié robuste.

Concurrency
Comparaison de Code
✕ 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);
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🧵

Meilleure isolation

Un pool de threads configurable évite que des tâches planifiées indépendantes partagent un seul worker fragile.

🛡

Exécution robuste

Une tâche en échec ne met pas fin au planificateur lui-même.

🎛

Cycle de vie maîtrisable

Futures, annulation, délais et arrêt utilisent les API standard des exécuteurs.

Ancienne Approche
Timer et TimerTask
Approche Moderne
ScheduledExecutorService
Depuis JDK
5
Difficulté
Intermédiaire
Support JDK
Des tâches Timer aux exécuteurs planifiés
Disponible

Largement disponible depuis JDK 5 (sept. 2004)

Comment ça fonctionne

Timer exécute chaque tâche sur un seul thread, de sorte qu'une tâche longue retarde les autres, et une exception non interceptée met fin au thread du timer. ScheduledExecutorService utilise le framework des exécuteurs, prend en charge plusieurs workers, renvoie des handles ScheduledFuture et offre une gestion explicite du cycle de vie. Le composant propriétaire doit arrêter le planificateur lorsqu'il n'est plus nécessaire.

Documentation Associée
ScheduledExecutorService ↗ Executors ↗
Preuve
Voir la preuve source ↗
Patterns associés
Concurrency Débutant

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
Survolez pour voir le moderne ➜
JDK 19+ →
Concurrency Débutant

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)
);
Survolez pour voir le moderne ➜
JDK 19+ →
Concurrency Avancé

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());
}
Survolez pour voir le moderne ➜
JDK 25+ →