Home / Concurrency / Thread.sleep with Duration
Concurrency beginner

Thread.sleep with Duration

Use Duration for self-documenting time values.

Code Comparison
✕ 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)
);
Why the modern way wins
📖

Self-documenting

Duration.ofSeconds(5) is unambiguous.

🛡️

Unit-safe

No accidentally passing microseconds as milliseconds.

🧩

Composable

Duration math: plus(), multipliedBy(), etc.

Old Approach
Milliseconds
Modern Approach
Duration
Since JDK
19
Difficulty
beginner
JDK Support
Thread.sleep with Duration
Available

Widely available since JDK 19 (Sept 2022)

How it works

Thread.sleep(Duration) makes the time unit explicit. No more guessing whether 5000 means milliseconds or microseconds. Works with Duration.ofSeconds, ofMillis, ofMinutes, etc.

Related patterns

Concurrency advanced

Stable values

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

Logger getLogger() {
    return logger.get();
}
Hover to see modern ➜
JDK 25+ →
Concurrency intermediate

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 to see modern ➜
JDK 21+ →
Concurrency intermediate

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(System.out::println);
Hover to see modern ➜
JDK 8+ →
Share 𝕏 🦋 in ⬡