CKTIS / Java
TimeUnit : millisecondes, nanosecondes et tryLock avec délai
Convertissez des millisecondes en nanosecondes et indiquez l’unité correspondant à la valeur du délai passé à `tryLock`.
Version : Java SE 21
Syntaxe
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 est une constante de l’énumération java.util.concurrent.TimeUnit. Elle désigne une unité (la milliseconde), pas une durée précise ni une valeur lue sur une horloge. TimeUnit.toNanos est une méthode d’instance : unit.toNanos(duration) prend un long exprimé dans l’unité unit et renvoie un long en nanosecondes.
Une milliseconde vaut 1 000 000 de nanosecondes. Ainsi, TimeUnit.MILLISECONDS.toNanos(250L) renvoie 250000000L. Si le résultat exact est hors de l’intervalle de long, la méthode renvoie Long.MAX_VALUE au-dessus de la borne supérieure ou Long.MIN_VALUE en dessous de la borne inférieure. Le dépassement ne déclenche pas d’exception et le résultat ne reboucle pas à l’autre extrémité de l’intervalle.
Dans ReentrantLock.tryLock(long, TimeUnit), l’unité indique comment interpréter le premier argument. Utilisez directement lock.tryLock(250L, TimeUnit.MILLISECONDS) ou, après conversion, lock.tryLock(250000000L, TimeUnit.NANOSECONDS). Les deux appels fixent la même limite d’attente pour acquérir le verrou. N’associez pas la valeur convertie à MILLISECONDS : choisir les nanosecondes ne garantit pas une précision d’attente à la nanoseconde.
La surcharge avec délai renvoie true si le verrou est acquis (y compris de nouveau par le même thread) et false si le délai expire sans acquisition. Un délai <= 0 signifie qu’elle n’attend pas. Elle respecte le réglage d’équité du verrou et lève InterruptedException si le thread est interrompu à l’entrée ou pendant l’acquisition, en effaçant son état d’interruption. Sans argument, tryLock() n’attend pas, peut passer devant les threads en file d’attente et ne lève pas InterruptedException. Une unité null dans la surcharge avec délai provoque une NullPointerException. N’appelez unlock() dans finally qu’après une acquisition réussie.
Exemples
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");
}
}
}Résultat
250 ms = 250000000 ns Lock acquired
Le programme affiche le résultat de la conversion, mais fournit à `tryLock` la valeur initiale en millisecondes. Le verrou neuf est libre et aucun autre thread ne le demande : l’exemple montre une acquisition réussie, pas l’expiration du délai.
Leçons associées
- Java · Leçon 54 · Intermédiaire · Version : 2