Conversão de segundos para milissegundos na prática
A conta é simples: um segundo equivale a mil milissegundos. O fator de conversão é fixo, baseado no Sistema Internacional de Unidades, e não varia de contexto. Multiplicar o valor em segundos por 1.000 dá o resultado em milissegundos. Mas a teoria é só a parte mais fácil do processo.
1 segundo em milisegundos: como funciona no dia a dia
Eu trabalhava com um sistema de logs de alta frequência que precisava converter timestamps de uma API que retornava segundos com até três casas decimais para milissegundos inteiros de forma confiável. O problema era que alguns desenvolvedores estavam usando aritmética de ponto flutuante diretamente — multiplicar 0,199 por 1.000 e esperar um inteiro exato. Isso gera valores como 198,99999999999997, e ao aplicar Math.floor() ou parseInt(), você perde um milissegundo sem perceber. A correção foi usar round() antes de converter para inteiro, o que eliminou erros intermitentes em testes de sincronização que levaram dois dias para serem identificados. O cálculo em si continua sendo o mesmo. 1 segundo por 1.000 dá exatamente 1.000 milissegundos. O que costuma complicar é quando você lida com frações de segundo em linguagens que tratam números decimais de forma imprecisa, especialmente JavaScript com seus problemas históricos de precisão em ponto flutuante.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Em Python, a coisa é mais direta. A biblioteca datetime e o módulo time trabalham naturalmente com float, e a conversão é simplesmente segundos * 1000. Em C ou C++, se você estiver lidando com struct timespec ou usleep, precisa ter cuidado com overflow se os valores forem grandes demais para inteiros de 32 bits. Um timeout de 50 segundos em milissegundos cabe num int, mas algo acima de 24 dias já exige long long ou int64_t. O pitfall mais comum que eu vejo em code review é a confusão entre segundos e milissegundos em chamadas de API. Você passa um timeout de 5 segundos numa biblioteca que espera milissegundos, e seu serviço fica travado por 5.000 milissegundos em vez dos 5 esperados. O oposto também acontece: passar milissegundos onde o parâmetro espera segundos. Isso é especialmente perigoso em chamadas de rede porque o erro se manifesta como timeout prematuro ou demora excessiva, e o log raramente aponta a causa raiz imediatamente.
Uma nuance que pouca gente considera é a questão da precisão versus granularity. Em sistemas operacionais modernos, o scheduler nem sempre consegue precessar com resolução de 1 milissegundo real. No Linux, a frequência do timer do kernel (CONFIG_HZ) define o tick mínimo. Com HZ=250, cada tick são 4 milissegundos. Configurar um timer de 1ms ou 2ms não vai fazer o que você espera — o sistema vai arredondar para o próximo tick. Se você precisa de latência abaixo disso, precisa olhar para hrtimers ou timers de alta resolução, que existem mas têm overhead maior. Em Java, o System.currentTimeMillis() retorna milissegundos desde a epoch, mas a granularidade real depende do sistema operacional e da JVM. Em ambientes de nuvem com containers, especialmente em provedores que fazem overcommit de CPU, os timers podem ter drift significativo. Eu vi casos onde um timer marcado para 1 segundo em milissegundos (1000ms) efetivamente disparava com variação de ±50ms em instâncias EC2 com burstable performance.
Se o seu cenário envolve medições de performance crítica, considere usar clock_gettime(CLOCK_MONOTONIC) no lugar de conversões ingênuas de timestamps. A diferença entre wall-clock time e monotonic time é exatamente o tipo de problema que aparece quando você menos espera — mudanças de horário do sistema, NTP syncs, leap seconds. Qualquer coisa que dependa de conversão de segundos para milissegundos a partir de um relógio parede pode dar errado se o relógio for ajustado durante a medição. Para a grande maioria dos casos, multiplicar por 1.000 e usar round() antes de converter para inteiro é suficiente. Se você está construindo infraestrutura de tempo real, aí as coisas ficam mais complicadas e o custo de uma conversão errada é bem mais alto do que o custo de fazer certo desde o início.
