System.currentTimeMillis vs System.nanoTime

Precisão vs. Precisão

O que eu gostaria de saber é se devo usar System.currentTimeMillis () ou System.nanoTime () ao atualizar as posições do meu objeto no meu jogo? A mudança de movimento deles é diretamente proporcional ao tempo decorrido desde a última ligação e eu quero ser o mais preciso possível.

Eu li que existem alguns problemas sérios de resolução de tempo entre diferentes sistemas operacionais (ou seja, que o Mac / Linux tem uma resolução de quase 1 ms, enquanto o Windows tem uma resolução de 50ms?). Estou executando meus aplicativos principalmente no Windows e a resolução de 50ms parece bastante imprecisa.

Existem opções melhores que as duas que eu listei?

Alguma sugestão / comentário?

Se você está apenas procurando medições extremamente precisas do tempo decorrido , use System.nanoTime(). System.currentTimeMillis()fornecerá o tempo decorrido possível mais preciso possível em milissegundos desde a época, mas fornecerá System.nanoTime()um tempo nanosegundo preciso, em relação a algum ponto arbitrário.

Na documentação Java:

public static long nanoTime()

Retorna o valor atual do timer de sistema disponível mais preciso, em nanossegundos.

Este método pode ser usado apenas para medir o tempo decorrido e não está relacionado a nenhuma outra noção de sistema ou hora do relógio de parede. O valor retornado representa nanossegundos desde algum tempo de origem fixo, mas arbitrário (talvez no futuro, portanto, os valores podem ser negativos). Este método fornece precisão em nanossegundos, mas não necessariamente precisão em nanossegundos. Não há garantias sobre a frequência com que os valores mudam. As diferenças nas chamadas sucessivas que ultrapassam aproximadamente 292 anos (2 ⁶³ nanossegundos) não calcularão com precisão o tempo decorrido devido ao excesso numérico.

Por exemplo, para medir quanto tempo um código leva para executar:

long startTime = System.nanoTime();    
// ... the code being measured ...    
long estimatedTime = System.nanoTime() - startTime;

Consulte também: JavaDoc System.nanoTime () e JavaDoc System.currentTimeMillis () para obter mais informações.

Desde que mais ninguém mencionou isso ...

Não é seguro comparar os resultados de System.nanoTime()chamadas entre diferentes segmentos. Mesmo que os eventos dos encadeamentos ocorram em uma ordem previsível, a diferença em nanossegundos pode ser positiva ou negativa.

System.currentTimeMillis() é seguro para uso entre threads.

Atualização por Arkadiy : observei um comportamento mais correto System.currentTimeMillis()no Windows 7 no Oracle Java 8. O tempo foi retornado com precisão de 1 milissegundo. O código-fonte do OpenJDK não mudou, então não sei o que causa o melhor comportamento.

David Holmes, da Sun, publicou um artigo no blog há alguns anos, que tem uma visão muito detalhada das APIs de tempo de Java (em particular System.currentTimeMillis()e System.nanoTime()), quando você deseja usar quais e como elas funcionam internamente.

Dentro da VM do ponto de acesso: relógios, cronômetros e eventos de agendamento - Parte I - Windows

Um aspecto muito interessante do timer usado pelo Java no Windows para APIs que possuem um parâmetro de espera temporizada é que a resolução do timer pode mudar dependendo de outras chamadas de API que tenham sido feitas - em todo o sistema (não apenas no processo específico) . Ele mostra um exemplo em que o uso Thread.sleep()causará essa alteração na resolução.

System.nanoTime()não é suportado em JVMs mais antigas. Se isso é uma preocupação, fique comcurrentTimeMillis

Em relação à precisão, você está quase correto. Em algumas máquinas Windows, currentTimeMillis()tem uma resolução de cerca de 10ms (não 50ms). Não sei por que, mas algumas máquinas Windows são tão precisas quanto as máquinas Linux.

Eu usei GAGETimer no passado com sucesso moderado.

Como já foi dito, currentTimeMillis é a hora do relógio, que muda devido ao horário de verão, usuários alterando as configurações de hora, segundos bissextos e sincronização da hora da Internet. Se o seu aplicativo depende do aumento monotônico dos valores de tempo decorrido, você pode preferir o nanoTime.

Você pode pensar que os jogadores não vão mexer com as configurações de tempo durante o jogo, e talvez você esteja certo. Mas não subestime a interrupção devido à sincronização da hora da Internet ou talvez a usuários de computadores remotos. A API nanoTime é imune a esse tipo de interrupção.

Se você quiser usar a hora do relógio, mas evitar descontinuidades devido à sincronização da hora da Internet, considere um cliente NTP como o Meinberg, que "ajusta" a taxa do relógio para zerá-lo, em vez de apenas redefinir o relógio periodicamente.

Eu falo por experiência própria. Em um aplicativo climático que desenvolvi, eu estava obtendo picos de velocidade do vento que ocorriam aleatoriamente. Demorou um pouco para eu perceber que minha base de tempo estava sendo interrompida pelo comportamento da hora do relógio em um PC típico. Todos os meus problemas desapareceram quando comecei a usar o nanoTime. A consistência (monotonicidade) foi mais importante para minha aplicação do que a precisão bruta ou a precisão absoluta.

Sim, se essa precisão for necessária System.nanoTime(), use , mas lembre-se de que você está exigindo uma JVM Java 5+.

Nos meus sistemas XP, vejo a hora do sistema relatada em pelo menos 100 microssegundos 278 nanossegundos usando o seguinte código:

private void test() {
    System.out.println("currentTimeMillis: "+System.currentTimeMillis());
    System.out.println("nanoTime         : "+System.nanoTime());
    System.out.println();

    testNano(false);                                                            // to sync with currentTimeMillis() timer tick
    for(int xa=0; xa<10; xa++) {
        testNano(true);
        }
    }

private void testNano(boolean shw) {
    long strMS=System.currentTimeMillis();
    long strNS=System.nanoTime();
    long curMS;
    while((curMS=System.currentTimeMillis()) == strMS) {
        if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)); }
        }
    if(shw) { System.out.println("Nano: "+(System.nanoTime()-strNS)+", Milli: "+(curMS-strMS)); }
    }

Para gráficos de jogos e atualizações de posição suaves, use em System.nanoTime()vez de System.currentTimeMillis(). Eu mudei de currentTimeMillis () para nanoTime () em um jogo e obtive uma grande melhoria visual na suavidade do movimento.

Embora um milissegundo possa parecer que já deveria ser preciso, visualmente não é. Os fatores que nanoTime()podem melhorar incluem:

• posicionamento preciso de pixels abaixo da resolução do relógio de parede
• capacidade de anti-alias entre pixels, se você quiser
• Imprecisão do relógio de parede do Windows
• tremulação do relógio (inconsistência de quando o relógio de parede realmente avança)

Como outras respostas sugerem, o nanoTime tem um custo de desempenho se chamado repetidamente - seria melhor chamá-lo apenas uma vez por quadro e usar o mesmo valor para calcular o quadro inteiro.

Eu tive uma boa experiência com nanotime . Ele fornece o tempo do relógio de parede como dois longos (segundos desde a época e nanossegundos nesse segundo), usando uma biblioteca JNI. Está disponível com a parte JNI pré-compilada para Windows e Linux.

System.currentTimeMillis()não é seguro por tempo decorrido, porque esse método é sensível às alterações do relógio em tempo real do sistema. Você deveria usar System.nanoTime. Consulte a ajuda do sistema Java:

Sobre o método nanoTime:

.. Este método fornece precisão em nanossegundos, mas não necessariamente resolução em nanossegundos (ou seja, com que frequência o valor é alterado) - nenhuma garantia é feita, exceto que a resolução é pelo menos tão boa quanto a de currentTimeMillis () ..

Se você usar System.currentTimeMillis()o tempo decorrido, pode ser negativo (Voltar <- para o futuro)

uma coisa aqui é a inconsistência do método nanoTime. ele não fornece valores muito consistentes para a mesma entrada. e, portanto, mais precisão em seu valor. portanto, sugiro que você use currentTimeMillis