CKTIS / Java
TimeUnit: millisecondi, nanosecondi e tryLock con timeout
Converti i millisecondi in nanosecondi e usa l’unità corrispondente al valore del timeout passato a `tryLock`.
Versione: Java SE 21
Sintassi
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
long timeoutNanos = TimeUnit.MILLISECONDS.toNanos(timeoutMillis);
// For either timed tryLock call, catch InterruptedException or declare it in the enclosing method's throws clause.
boolean acquired = lock.tryLock(timeoutMillis, TimeUnit.MILLISECONDS);
// Alternative to the preceding call, not a second acquisition:
// boolean acquired = lock.tryLock(timeoutNanos, TimeUnit.NANOSECONDS);TimeUnit.MILLISECONDS è una costante dell’enumerazione java.util.concurrent.TimeUnit. Indica un’unità (il millisecondo), non un valore di durata né una lettura dell’orologio. TimeUnit.toNanos è un metodo di istanza: unit.toNanos(duration) riceve un long espresso nell’unità unit e restituisce un long in nanosecondi.
Un millisecondo equivale a 1 000 000 di nanosecondi, quindi TimeUnit.MILLISECONDS.toNanos(250L) restituisce 250000000L. Se il risultato esatto è fuori dall’intervallo di long, il metodo restituisce Long.MAX_VALUE sopra il limite superiore o Long.MIN_VALUE sotto quello inferiore. L’overflow non genera un’eccezione e non fa saltare il risultato all’estremo opposto dell’intervallo.
In ReentrantLock.tryLock(long, TimeUnit), l’unità indica come interpretare il primo argomento. Usa direttamente lock.tryLock(250L, TimeUnit.MILLISECONDS) oppure, dopo la conversione, lock.tryLock(250000000L, TimeUnit.NANOSECONDS). Entrambe le chiamate impostano lo stesso limite di attesa per acquisire il lock. Non associare il numero convertito a MILLISECONDS: usare i nanosecondi come unità non garantisce una precisione di attesa al nanosecondo.
L’overload con timeout restituisce true quando il lock viene acquisito (anche di nuovo dallo stesso thread) e false se il tempo scade senza acquisizione. Un timeout <= 0 significa che non si attende. Questo overload rispetta l’impostazione di equità del lock e, se il thread è interrotto all’ingresso o durante l’acquisizione, lancia InterruptedException e azzera lo stato di interruzione. tryLock() senza argomenti non attende, può scavalcare i thread in coda e non lancia InterruptedException. Un’unità null nell’overload con timeout causa NullPointerException. Chiama unlock() in finally solo dopo aver acquisito il lock.
Esempi
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class Main {
public static void main(String[] args) throws InterruptedException {
long timeoutMillis = 250L;
long timeoutNanos = TimeUnit.MILLISECONDS.toNanos(timeoutMillis);
System.out.println(timeoutMillis + " ms = " + timeoutNanos + " ns");
ReentrantLock lock = new ReentrantLock();
if (lock.tryLock(timeoutMillis, TimeUnit.MILLISECONDS)) {
try {
System.out.println("Lock acquired");
} finally {
lock.unlock();
}
} else {
System.out.println("Lock not acquired");
}
}
}Risultato
250 ms = 250000000 ns Lock acquired
Il programma stampa il risultato della conversione, ma passa a `tryLock` il valore originale in millisecondi. Il nuovo lock è libero e nessun altro thread lo contende: l’esempio mostra l’acquisizione, non la scadenza del timeout.
Lezioni correlate
- Java · Lezione 54 · Intermedio · Versione: 2