System.currentTimeMillis vs System.nanoTime

Précision contre. Précision

Ce que je voudrais savoir, c'est si je dois utiliser System.currentTimeMillis () ou System.nanoTime () lors de la mise à jour des positions de mon objet dans mon jeu? Leur changement de mouvement est directement proportionnel au temps écoulé depuis le dernier appel et je veux être aussi précis que possible.

J'ai lu qu'il existe de sérieux problèmes de résolution temporelle entre différents systèmes d'exploitation (à savoir que Mac / Linux ont une résolution de près de 1 ms tandis que Windows a une résolution de 50 ms ??). J'exécute principalement mes applications sur Windows et la résolution de 50 ms semble assez inexacte.

Y a-t-il de meilleures options que les deux que j'ai énumérées?

Des suggestions / commentaires?

Si vous recherchez simplement des mesures extrêmement précises du temps écoulé , utilisez System.nanoTime(). System.currentTimeMillis()vous donnera le temps écoulé le plus précis possible en millisecondes depuis l'époque, mais System.nanoTime()vous donne un temps précis en nanosecondes, par rapport à un point arbitraire.

De la documentation Java:

public static long nanoTime()

Renvoie la valeur actuelle du minuteur système le plus précis disponible, en nanosecondes.

Cette méthode ne peut être utilisée que pour mesurer le temps écoulé et n'est liée à aucune autre notion de temps système ou d'horloge murale. La valeur renvoyée représente des nanosecondes depuis un certain temps d' origine fixe mais arbitraire (peut-être à l'avenir, donc les valeurs peuvent être négatives). Cette méthode fournit une précision en nanosecondes, mais pas nécessairement une précision en nanosecondes. Aucune garantie n'est donnée sur la fréquence à laquelle les valeurs changent. Les différences d'appels successifs qui s'étendent sur plus de 292 ans environ (2 ⁶³ nanosecondes) ne permettront pas de calculer avec précision le temps écoulé en raison d'un débordement numérique.

Par exemple, pour mesurer la durée d'exécution d'un code:

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

Voir aussi: JavaDoc System.nanoTime () et JavaDoc System.currentTimeMillis () pour plus d'informations.

Puisque personne d'autre ne l'a mentionné…

Il n'est pas sûr de comparer les résultats des System.nanoTime()appels entre différents threads. Même si les événements des threads se produisent dans un ordre prévisible, la différence en nanosecondes peut être positive ou négative.

System.currentTimeMillis() est sûr pour une utilisation entre les threads.

Mise à jour d' Arkadiy : j'ai observé un comportement plus correct deSystem.currentTimeMillis() Windows 7 dans Oracle Java 8. L'heure a été renvoyée avec une précision d'une milliseconde. Le code source dans OpenJDK n'a pas changé, donc je ne sais pas ce qui cause le meilleur comportement.

David Holmes de Sun a publié il y a quelques années un article de blog qui présente de manière très détaillée les API de synchronisation Java (en particulier System.currentTimeMillis()etSystem.nanoTime() ), quand vous souhaitez les utiliser et comment elles fonctionnent en interne.

À l'intérieur de la machine virtuelle Hotspot: horloges, minuteurs et événements de planification - Partie I - Windows

Un aspect très intéressant du minuteur utilisé par Java sur Windows pour les API qui ont un paramètre d'attente temporisée est que la résolution du minuteur peut changer en fonction des autres appels d'API qui ont été effectués - à l'échelle du système (pas seulement dans le processus particulier) . Il montre un exemple où l'utilisation Thread.sleep()entraînera ce changement de résolution.

System.nanoTime()n'est pas pris en charge dans les anciennes machines virtuelles Java. Si cela vous préoccupe, restez aveccurrentTimeMillis

Concernant la précision, vous avez presque raison. Sur CERTAINES machines Windows,currentTimeMillis() a une résolution d'environ 10 ms (et non 50 ms). Je ne sais pas pourquoi, mais certaines machines Windows sont tout aussi précises que les machines Linux.

J'ai utilisé GAGETimer dans le passé avec un succès modéré.

Comme d'autres l'ont dit, currentTimeMillis est l'heure de l'horloge, qui change en raison de l'heure d'été, des utilisateurs changeant les paramètres de l'heure, des secondes intercalaires et de la synchronisation de l'heure Internet. Si votre application dépend de l'augmentation monotone des valeurs de temps écoulé, vous préférerez peut-être nanoTime à la place.

Vous pourriez penser que les joueurs ne joueront pas avec les paramètres de temps pendant le jeu, et peut-être auriez-vous raison. Mais ne sous-estimez pas la perturbation due à la synchronisation de l'heure Internet, ou peut-être aux utilisateurs de postes de travail distants. L'API nanoTime est à l'abri de ce type de perturbation.

Si vous souhaitez utiliser l'heure de l'horloge, mais évitez les discontinuités dues à la synchronisation de l'heure sur Internet, vous pouvez envisager un client NTP tel que Meinberg, qui "ajuste" la fréquence d'horloge pour la mettre à zéro, au lieu de simplement réinitialiser l'horloge périodiquement.

Je parle d'expérience personnelle. Dans une application météo que j'ai développée, j'obtenais des pointes de vitesse du vent aléatoires. Il m'a fallu un certain temps pour réaliser que ma base de temps était perturbée par le comportement de l'horloge sur un PC typique. Tous mes problèmes ont disparu lorsque j'ai commencé à utiliser nanoTime. La cohérence (monotonie) était plus importante pour mon application que la précision brute ou la précision absolue.

Oui, si une telle précision est requise, utilisez System.nanoTime() , sachez que vous avez alors besoin d'une JVM Java 5+.

Sur mes systèmes XP, je vois l'heure système signalée à au moins 100 microsecondes 278 nanosecondes en utilisant le code suivant:

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

Pour des graphiques de jeu et des mises à jour de position fluides, utilisez System.nanoTime()plutôt que System.currentTimeMillis(). Je suis passé de currentTimeMillis () à nanoTime () dans un jeu et j'ai obtenu une amélioration visuelle majeure de la fluidité du mouvement.

Alors qu'une milliseconde peut sembler être déjà précise, visuellement ce n'est pas le cas. Les facteurs nanoTime()peuvent s'améliorer, notamment:

• positionnement précis des pixels en dessous de la résolution de l'horloge murale
• possibilité d'anti-alias entre pixels, si vous le souhaitez
• Imprécision de l'horloge murale Windows
• gigue d'horloge (incohérence du moment où l'horloge murale avance réellement)

Comme d'autres réponses le suggèrent, nanoTime a un coût de performance s'il est appelé à plusieurs reprises - il serait préférable de l'appeler une seule fois par trame et d'utiliser la même valeur pour calculer la trame entière.

J'ai une bonne expérience avec le nanotime . Il fournit une horloge murale en deux longs (secondes depuis l'époque et nanosecondes dans cette seconde), en utilisant une bibliothèque JNI. Il est disponible avec la partie JNI précompilée pour Windows et Linux.

System.currentTimeMillis()n'est pas sûr pour le temps écoulé car cette méthode est sensible aux changements d'horloge en temps réel du système. Tu devrais utiliserSystem.nanoTime . Veuillez consulter l'aide de Java System:

À propos de la méthode nanoTime:

.. Cette méthode fournit une précision en nanosecondes, mais pas nécessairement une résolution en nanosecondes (c'est-à-dire la fréquence à laquelle la valeur change) - aucune garantie n'est apportée, sauf que la résolution est au moins aussi bonne que celle de currentTimeMillis () ..

Si vous utilisez System.currentTimeMillis()votre temps écoulé peut être négatif (Retour <- vers le futur)

une chose ici est l'incohérence de la méthode nanoTime.il ne donne pas de valeurs très cohérentes pour la même entrée.currentTimeMillis fait beaucoup mieux en termes de performances et de cohérence, et aussi, bien que pas aussi précis que nanoTime, a une marge d'erreur inférieure , et donc plus de précision dans sa valeur. je vous suggère donc d'utiliser currentTimeMillis