System.currentTimeMillis vs System.nanoTime

Precisione vs. Precisione

Quello che vorrei sapere è se dovrei usare System.currentTimeMillis () o System.nanoTime () quando aggiorno le posizioni dei miei oggetti nel mio gioco? Il loro cambio di movimento è direttamente proporzionale al tempo trascorso dall'ultima chiamata e voglio essere il più preciso possibile.

Ho letto che ci sono alcuni seri problemi di risoluzione temporale tra diversi sistemi operativi (vale a dire che Mac / Linux hanno una risoluzione di quasi 1 ms mentre Windows ha una risoluzione di 50ms ??). Sto eseguendo principalmente le mie app su Windows e la risoluzione di 50ms sembra piuttosto imprecisa.

Ci sono opzioni migliori rispetto alle due che ho elencato?

Qualche suggerimento / commento?

Se stai solo cercando misure estremamente precise del tempo trascorso , usa System.nanoTime(). System.currentTimeMillis()ti darà il tempo trascorso più preciso possibile in millisecondi dall'epoca, ma System.nanoTime()ti darà un tempo di nanosecondi preciso, rispetto ad un punto arbitrario.

Dalla documentazione Java:

public static long nanoTime()

Restituisce il valore corrente del timer di sistema disponibile più preciso, in nanosecondi.

Questo metodo può essere utilizzato solo per misurare il tempo trascorso e non è correlato ad alcuna altra nozione di tempo di sistema o di orologio da parete. Il valore restituito rappresenta i nanosecondi da un tempo di origine fisso ma arbitrario (forse in futuro, quindi i valori possono essere negativi). Questo metodo fornisce precisione dei nanosecondi, ma non necessariamente precisione dei nanosecondi. Non vengono fornite garanzie sulla frequenza con cui i valori cambiano. Le differenze nelle chiamate successive che si estendono per più di circa 292 anni (2 ⁶³ nanosecondi) non calcoleranno accuratamente il tempo trascorso a causa dell'overflow numerico.

Ad esempio, per misurare quanto tempo impiega il codice per eseguire:

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

Vedi anche: JavaDoc System.nanoTime () e JavaDoc System.currentTimeMillis () per maggiori informazioni.

Dal momento che nessun altro ha menzionato questo ...

Non è sicuro confrontare i risultati delle System.nanoTime()chiamate tra thread diversi. Anche se gli eventi dei thread si verificano in un ordine prevedibile, la differenza in nanosecondi può essere positiva o negativa.

System.currentTimeMillis() è sicuro per l'uso tra i thread.

Aggiornamento di Arkadiy : ho osservato un comportamento più corretto System.currentTimeMillis()su Windows 7 in Oracle Java 8. Il tempo è stato restituito con precisione di 1 millisecondo. Il codice sorgente in OpenJDK non è cambiato, quindi non so quale sia la causa del comportamento migliore.

David Holmes di Sun ha pubblicato un articolo di blog un paio di anni fa che ha uno sguardo molto dettagliato alle API di timing Java (in particolare System.currentTimeMillis()e System.nanoTime()), quando si desidera utilizzare quali e come funzionano internamente.

All'interno della VM Hotspot: orologi, timer ed eventi di pianificazione - Parte I - Windows

Un aspetto molto interessante del timer utilizzato da Java su Windows per le API che hanno un parametro di attesa a tempo è che la risoluzione del timer può cambiare a seconda di quali altre chiamate API potrebbero essere state effettuate - a livello di sistema (non solo nel particolare processo) . Mostra un esempio in cui l'utilizzo Thread.sleep()causerà questo cambiamento di risoluzione.

System.nanoTime()non è supportato nelle JVM precedenti. Se questo è un problema, resta concurrentTimeMillis

Per quanto riguarda la precisione, hai quasi ragione. Su alcuni computer Windows, currentTimeMillis()ha una risoluzione di circa 10 ms (non 50 ms). Non sono sicuro del perché, ma alcune macchine Windows sono altrettanto precise delle macchine Linux.

Ho usato GAGETimer in passato con discreto successo.

Come altri hanno già detto, currentTimeMillis è l'ora dell'orologio, che cambia a causa dell'ora legale, degli utenti che cambiano le impostazioni dell'ora, dei secondi intercalari e della sincronizzazione dell'ora di Internet. Se la tua app dipende dall'aumento monotonico dei valori di tempo trascorso, potresti preferire nanoTime.

Potresti pensare che i giocatori non giocheranno con le impostazioni del tempo durante il gioco, e forse avresti ragione. Ma non sottovalutare l'interruzione dovuta alla sincronizzazione dell'ora di Internet o agli utenti desktop remoti. L'API nanoTime è immune da questo tipo di interruzione.

Se si desidera utilizzare l'ora, ma evitare discontinuità dovute alla sincronizzazione dell'ora di Internet, si potrebbe prendere in considerazione un client NTP come Meinberg, che "sintonizza" la frequenza di clock per azzerarla, invece di reimpostare periodicamente l'orologio.

Parlo per esperienza personale. In un'applicazione meteorologica che ho sviluppato, stavo ottenendo picchi di velocità del vento casuali. Mi ci è voluto un po 'per capire che la mia base dei tempi era stata interrotta dal comportamento dell'orologio su un tipico PC. Tutti i miei problemi sono scomparsi quando ho iniziato a utilizzare nanoTime. La coerenza (monotonia) era più importante per la mia applicazione della precisione pura o assoluta.

Sì, se è richiesta una tale precisione, è necessario System.nanoTime()tenere presente che è necessario un JVM Java 5+.

Sui miei sistemi XP, vedo l'ora di sistema riportata ad almeno 100 microsecondi 278 nanosecondi utilizzando il seguente codice:

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)); }
    }

Per gioco e grafica aggiornamenti di posizione ottimale, usare System.nanoTime()piuttosto che System.currentTimeMillis(). Sono passato da currentTimeMillis () a nanoTime () in un gioco e ho ottenuto un notevole miglioramento visivo della scorrevolezza dei movimenti.

Mentre un millisecondo può sembrare che dovrebbe essere già preciso, visivamente non lo è. I fattori che nanoTime()possono migliorare includono:

• posizionamento preciso dei pixel al di sotto della risoluzione dell'orologio da parete
• possibilità di anti-alias tra i pixel, se lo si desidera
• Inesattezza dell'orologio da parete di Windows
• clock jitter (incoerenza del momento in cui l'orologio da parete scorre in avanti)

Come suggeriscono altre risposte, nanoTime ha un costo in termini di prestazioni se chiamato ripetutamente: sarebbe meglio chiamarlo una sola volta per frame e utilizzare lo stesso valore per calcolare l'intero frame.

Ho avuto una buona esperienza con il nanotime . Fornisce il tempo dell'orologio da parete come due lunghi (secondi dall'epoca e nanosecondi entro quel secondo), usando una libreria JNI. È disponibile con la parte JNI precompilata sia per Windows che per Linux.

System.currentTimeMillis()non è sicuro per il tempo trascorso perché questo metodo è sensibile alle modifiche dell'orologio in tempo reale del sistema. Si dovrebbe usare System.nanoTime. Fare riferimento alla guida di Java System:

Informazioni sul metodo nanoTime:

.. Questo metodo fornisce una precisione di nanosecondi, ma non necessariamente una risoluzione di nanosecondi (ovvero, con che frequenza cambia il valore) - non viene fornita alcuna garanzia se non che la risoluzione è almeno pari a quella di currentTimeMillis () ..

Se si utilizza System.currentTimeMillis()il tempo trascorso può essere negativo (Indietro <- al futuro)

una cosa qui è l'incoerenza del metodo nanoTime.it non fornisce valori molto coerenti per lo stesso input.currentTimeMillis fa molto meglio in termini di prestazioni e coerenza e anche, sebbene non così preciso come nanoTime, ha un margine di errore inferiore e quindi una maggiore precisione nel suo valore. quindi suggerirei di usare currentTimeMillis