Strona główna / Concurrency / Thread.sleep with Duration
Concurrency Początkujący

Thread.sleep with Duration

Use Duration for self-documenting time values.

Porównanie kodu
✕ 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)
);
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
📖

Self-documenting

Duration.ofSeconds(5) is unambiguous.

🛡️

Unit-safe

No accidentally passing microseconds as milliseconds.

🧩

Composable

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

Stare podejście
Milliseconds
Nowoczesne podejście
Duration
Od JDK
19
Poziom trudności
Początkujący
Wsparcie JDK
Thread.sleep with Duration
Dostępne

Widely available since JDK 19 (Sept 2022)

Jak to działa

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

Powiązana dokumentacja
Thread.sleep(Duration) ↗
Powiązane wzorce
Concurrency Zaawansowany

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();
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Concurrency Średniozaawansowany

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();
}
Najedź, aby zobaczyć nową wersję ➜
JDK 21+ →
Concurrency Średniozaawansowany

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);
Najedź, aby zobaczyć nową wersję ➜
JDK 8+ →
Udostępnij 𝕏 🦋 in ⬡