Startseite / Concurrency / Thread.sleep mit Duration
Concurrency Einsteiger

Thread.sleep mit Duration

Duration für selbstdokumentierende Zeitangaben verwenden.

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

Selbstdokumentierend

Duration.ofSeconds(5) ist eindeutig.

🛡️

Einheitensicher

Kein versehentliches Übergeben von Mikrosekunden als Millisekunden.

🧩

Kombinierbar

Duration-Arithmetik: plus(), multipliedBy() usw.

Alter Ansatz
Millisekunden
Moderner Ansatz
Duration
Seit JDK
19
Schwierigkeitsgrad
Einsteiger
JDK-Unterstützung
Thread.sleep mit Duration
Verfügbar

Weitgehend verfügbar seit JDK 19 (Sept. 2022)

Wie es funktioniert

Thread.sleep(Duration) macht die Zeiteinheit explizit. Kein Rätselraten mehr, ob 5000 Millisekunden oder Mikrosekunden bedeutet. Funktioniert mit Duration.ofSeconds, ofMillis, ofMinutes usw.

Zugehörige Dokumentation
Thread.sleep(Duration) ↗
Verwandte Muster
Concurrency Experte

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();
}
Hover für Modernes ➜
JDK 25+ →
Concurrency Fortgeschritten

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();
}
Hover für Modernes ➜
JDK 21+ →
Concurrency Fortgeschritten

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);
Hover für Modernes ➜
JDK 8+ →
Teilen 𝕏 🦋 in ⬡