Home / Concurrency / Thread.sleep con Duration
Concurrency Principiante

Thread.sleep con Duration

Usa Duration per valori di tempo auto-documentanti.

Confronto Codice
✕ 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)
);
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
📖

Auto-documentante

Duration.ofSeconds(5) è inequivocabile.

🛡️

Sicuro per unità

Nessun rischio di passare accidentalmente microsecondi come millisecondi.

🧩

Componibile

Aritmetica Duration: plus(), multipliedBy(), ecc.

Approccio Vecchio
Millisecondi
Approccio Moderno
Duration
Dal JDK
19
Difficoltà
Principiante
Supporto JDK
Thread.sleep con Duration
Disponibile

Ampiamente disponibile dal JDK 19 (settembre 2022)

Come funziona

Thread.sleep(Duration) rende l'unità di tempo esplicita. Non serve più indovinare se 5000 significa millisecondi o microsecondi. Funziona con Duration.ofSeconds, ofMillis, ofMinutes, ecc.

Documentazione Correlata
Thread.sleep(Duration) ↗
Pattern correlati
Concurrency Avanzato

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();
}
Passa il mouse per vedere il moderno ➜
JDK 25+ →
Concurrency Intermedio

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();
}
Passa il mouse per vedere il moderno ➜
JDK 21+ →
Concurrency Intermedio

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);
Passa il mouse per vedere il moderno ➜
JDK 8+ →
Condividi 𝕏 🦋 in ⬡