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)
);
See a problem with this code? Let us know.
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 Documentation
Thread.sleep(Duration) โ†—
Proof
View proof source โ†—
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 (Preview)
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(IO::println);
Hover to see modern โžœ
JDK 8+ โ†’
Share ๐• ๐Ÿฆ‹ in โฌก