Accueil / Concurrency / Thread.sleep avec Duration
Concurrency Débutant

Thread.sleep avec Duration

Utilisez Duration pour des valeurs temporelles auto-documentées.

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

Auto-documenté

Duration.ofSeconds(5) est sans ambiguïté.

🛡️

Sûr en termes d'unités

Sans passer accidentellement des microsecondes comme des millisecondes.

🧩

Composable

Arithmétique avec Duration : plus(), multipliedBy(), etc.

Ancienne Approche
Millisecondes
Approche Moderne
Duration
Depuis JDK
19
Difficulté
Débutant
Support JDK
Thread.sleep avec Duration
Disponible

Disponible depuis JDK 19 (sept. 2022)

Comment ça fonctionne

Thread.sleep(Duration) rend l'unité de temps explicite. Plus besoin de deviner si 5000 signifie des millisecondes ou des microsecondes. Fonctionne avec Duration.ofSeconds, ofMillis, ofMinutes, etc.

Documentation Associée
Thread.sleep(Duration) ↗
Patterns associés
Concurrency Avancé

Stable values

Java 8
private volatile Logger logger;
Logger getLogger() {
    if (logger == null) {
        synchronized (this) {
            if (logger == null)
                logger = createLogger();
        }
    }
    return logger;
}
Java 25 (Preview)
private final StableValue<Logger> logger =
    StableValue.of(this::createLogger);

Logger getLogger() {
    return logger.get();
}
Survolez pour voir le moderne ➜
JDK 25+ →
Concurrency Intermédiaire

Concurrent HTTP with virtual threads

Java 8
ExecutorService pool =
    Executors.newFixedThreadPool(10);
List<Future<String>> futures =
    urls.stream()
    .map(u -> pool.submit(
        () -> fetchUrl(u)))
    .toList();
// manual shutdown, blocking get()
Java 21+
try (var exec = Executors
    .newVirtualThreadPerTaskExecutor()) {
    var results = urls.stream()
        .map(u -> exec.submit(
            () -> client.send(req(u),
                ofString()).body()))
        .toList().stream()
        .map(Future::join).toList();
}
Survolez pour voir le moderne ➜
JDK 21+ →
Concurrency Intermédiaire

CompletableFuture chaining

Pre-Java 8
Future<String> future =
    executor.submit(this::fetchData);
String data = future.get(); // blocks
String result = transform(data);
Java 8+
CompletableFuture.supplyAsync(
    this::fetchData
)
.thenApply(this::transform)
.thenAccept(IO::println);
Survolez pour voir le moderne ➜
JDK 8+ →
Partager 𝕏 🦋 in ⬡