Tempo em milissegundos em Rust: 5 erros fatais e como evitá-los

Tempo em milissegundos em Rust: não caia nessas 5 armadilhas

«Como obtenho o tempo atual em milissegundos?» — esta pergunta do Stack Overflow reuniu milhares de visualizações. Parece que poderia ser mais simples? Mas o Rust não é Python nem JavaScript. Aqui é fácil confundir UNIX timestamp com tempo monotônico, esquecer da dependência de plataforma ou pisar em armadilhas de desempenho.

Neste artigo, analisaremos os principais erros que iniciantes (e não só) cometem ao trabalhar com tempo em Rust. Você aprenderá como obter o tempo em milissegundos de forma correta, confiável e rápida. Vamos lá!

Erro nº1: Tempo monotônico em vez de tempo UNIX

A armadilha mais comum é usar std::time::Instant para obter o «tempo atual». O Instant em Rust mede o tempo monotônico — é ideal para medir intervalos, mas absolutamente inútil se você precisar de um timestamp (por exemplo, para logging ou envio para um servidor).

// ❌ ERRO: assim não se obtém timestamp\nuse std::time::Instant;\n\nlet now = Instant::now();\n// Instant não tem o método duration_since(UNIX_EPOCH)!\n// Você receberá um erro de compilação\n

Como fazer corretamente? Use std::time::SystemTime. Este tipo conhece o tempo do sistema e pode contar a partir do UNIX_EPOCH (1 de janeiro de 1970).

use std::time::{SystemTime, UNIX_EPOCH};\n\nlet now = SystemTime::now()\n    .duration_since(UNIX_EPOCH)\n    .expect("O tempo voltou?");\n    \nlet millis = now.as_millis(); // u128\nprintln!("Tempo atual em ms: {}", millis);\n

💡 Dica: duration_since retorna um Result, porque teoricamente o tempo do sistema pode ser configurado para antes de 1970. Em sistemas modernos, esta exceção pode ser tratada com expect ou unwrap.

Erro nº2: Esquecer da dependência de plataforma

Parece que SystemTime::now() é uma solução multiplataforma. Mas há um detalhe. Em algumas plataformas (por exemplo, kernels Linux antigos ou sistemas embarcados), o SystemTime pode se comportar de forma instável ou nem suportar precisão de milissegundos.

Outra pedra no sapato é o estouro. O tipo u128 em as_millis() dificilmente estourará (dura bilhões de anos), mas se você precisar salvar o tempo em um banco de dados ou transmiti-lo pela rede — milissegundos em u128 podem ser uma surpresa para outros sistemas.

// ✅ Conversão segura para u64 (dura até ~584 milhões de anos)\nlet millis_u64: u64 = now.as_millis() as u64;\n

Como evitar? Sempre verifique a documentação para sua plataforma alvo. Para sistemas embarcados, considere o crate embassy-time ou use std::time com cuidado.

Erro nº3: Ignorar o crate chrono

A biblioteca padrão do Rust oferece funcionalidades básicas. Mas se você precisar trabalhar com fusos horários, formatação ou parsing de datas — não reinvente a roda. O crate chrono é o padrão de facto para trabalhar com data e hora em Rust.

// Adicione em Cargo.toml: chrono = "0.4"\nuse chrono::Utc;\n\nlet now = Utc::now();\nlet millis = now.timestamp_millis(); // i64\nprintln!("Chrono timestamp: {}", millis);\n

⚠️ Importante: timestamp_millis() retorna i64, não u128. Isso foi feito para compatibilidade com o tempo UNIX (que pode ser negativo para datas anteriores a 1970). Na maioria dos casos, i64 é o que você precisa.

💡 Co