CKTIS / Java
TimeUnit: milissegundos, nanossegundos e tryLock com limite de espera
Converte milissegundos em nanossegundos e usa a unidade correspondente ao valor do limite de espera passado a `tryLock`.
Versão: Java SE 21
Sintaxe
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 é uma constante da enumeração java.util.concurrent.TimeUnit. Representa uma unidade (o milissegundo), não um valor de duração nem uma leitura do relógio. TimeUnit.toNanos é um método de instância: unit.toNanos(duration) recebe um long expresso na unidade unit e devolve um long em nanossegundos.
Um milissegundo equivale a 1 000 000 de nanossegundos, pelo que TimeUnit.MILLISECONDS.toNanos(250L) devolve 250000000L. Se o resultado exato estiver fora do intervalo de long, o método devolve Long.MAX_VALUE acima do limite superior ou Long.MIN_VALUE abaixo do inferior. O transbordo não lança uma exceção nem faz o resultado saltar para o extremo oposto do intervalo.
Em ReentrantLock.tryLock(long, TimeUnit), a unidade indica como interpretar o primeiro argumento. Usa diretamente lock.tryLock(250L, TimeUnit.MILLISECONDS) ou, após a conversão, lock.tryLock(250000000L, TimeUnit.NANOSECONDS). Ambas as chamadas definem o mesmo limite de espera para adquirir o bloqueio. Não associes o valor convertido a MILLISECONDS: usar nanossegundos como unidade não garante uma precisão de espera ao nanossegundo.
A sobrecarga com limite de espera devolve true se o bloqueio for adquirido (inclusive de novo pela mesma thread) e false se o prazo terminar sem aquisição. Com um limite <= 0, não espera. Esta sobrecarga respeita a definição de equidade do bloqueio e, se a thread estiver interrompida à entrada ou for interrompida durante a aquisição, lança InterruptedException e limpa o estado de interrupção. tryLock() sem argumentos não espera, pode passar à frente de threads em fila e não lança InterruptedException. Uma unidade null na sobrecarga com limite provoca NullPointerException. Chama unlock() em finally apenas após uma aquisição bem-sucedida.
Exemplos
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");
}
}
}Resultado
250 ms = 250000000 ns Lock acquired
O programa apresenta o resultado da conversão, mas passa a `tryLock` o valor original em milissegundos. O novo bloqueio está livre e nenhuma outra thread compete por ele, pelo que o exemplo mostra uma aquisição bem-sucedida, não o fim do prazo.
Lições relacionadas
- Java · Lição 54 · Intermédio · Versão: 2