Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes