blocks|key|353792|text|旧版JVM不支持System.nanoTime()。如果您担心这一点，请继续使用currentTimeMillis|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|353793|关于准确性，你几乎是正确的。在某些Windows机上，currentTimeMillis()的分辨率约为10ms+(而非50ms)。我不知道为什么，但是一些Windows机器和Linux机器一样精确。|353794|我过去使用过GAGETimer，并取得了一定的成功。|353795|entityMap|0|LINK|mutability|MUTABLE|url|http://java.dnsalias.com/^0|8|H|14|H|0|R|J|0|6|9|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|Z|8|@]|D|@$9|10|A|11|1|12]]|E|$]]|$1|J|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

<code>System.nanoTime()</code> isn't supported in older JVMs. If that is a concern, stick with <code>currentTimeMillis</code>

Regarding accuracy, you are almost correct. On SOME Windows machines, <code>currentTimeMillis()</code> has a resolution of about 10ms (not 50ms). I'm not sure why, but some Windows machines are just as accurate as Linux machines.

I have used <a href="http://java.dnsalias.com/" rel="nofollow noreferrer">GAGETimer</a> in the past with moderate success.

blocks|key|3352515|text|Arkadiy更新:我在OracleJava8中观察到System.currentTimeMillis()在Windows7上更正确的行为。时间以1毫秒的精度返回。OpenJDK中的源代码没有更改，所以我不知道是什么原因导致了更好的行为。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3352516|3352517|Sun的David+Holmes在几年前发表了一篇博客文章，非常详细地介绍了Java+(特别是System.currentTimeMillis()和System.nanoTime())、您希望在什么时候使用它们以及它们是如何在内部工作的。|3352518|Inside+the+Hotspot+VM:+Clocks,+Timers+and+Scheduling+Events+-+Part+I+-+Windows|3352519|Windows上的Java为具有timed+wait参数的API使用的计时器的一个非常有趣的方面是，计时器的分辨率可以根据系统范围内(不仅仅是在特定进程中)进行的其他API调用而改变。他展示了一个使用Thread.sleep()将导致此分辨率更改的示例。|3352520|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/3458/arkadiy|1|https://web.archive.org/web/20160308031939/https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks^0|R|Q|0|7|0|0|0|1B|Q|22|H|0|0|26|1|0|2S|E|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|-4|5|6|7|12|8|@]|D|@]|E|$]]|$1|G|3|H|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|K|3|L|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

Update by <a href="https://stackoverflow.com/users/3458/arkadiy">Arkadiy</a>: I've observed more correct behavior of <code>System.currentTimeMillis()</code> on Windows 7 in Oracle Java 8. The time was returned with 1 millisecond precision. The source code in OpenJDK has not changed, so I do not know what causes the better behavior.

<hr>

David Holmes of Sun posted a blog article a couple years ago that has a very detailed look at the Java timing APIs (in particular <code>System.currentTimeMillis()</code> and <code>System.nanoTime()</code>), when you would want to use which, and how they work internally.

<a href="https://web.archive.org/web/20160308031939/https://blogs.oracle.com/dholmes/entry/inside_the_hotspot_vm_clocks" rel="nofollow noreferrer">Inside the Hotspot VM: Clocks, Timers and Scheduling Events - Part I - Windows</a>

One very interesting aspect of the timer used by Java on Windows for APIs that have a timed wait parameter is that the resolution of the timer can change depending on what other API calls may have been made - system wide (not just in the particular process). He shows an example where using <code>Thread.sleep()</code> will cause this resolution change.

blocks|key|3139734|text|我对nanotime有很好的体验。它使用JNI库提供两个长的挂钟时间(从纪元开始的秒数和该秒数内的纳秒数)。它可以通过为Windows和Linux预编译的JNI部分获得。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3139735|entityMap|0|LINK|mutability|MUTABLE|url|http://juliusdavies.ca/nanotime/^0|2|8|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I've had good experience with <a href="http://juliusdavies.ca/nanotime/" rel="nofollow">nanotime</a>. It provides wall-clock time as two longs (seconds since the epoch and nanoseconds within that second), using a JNI library. It's available with the JNI part precompiled for both Windows and Linux.

blocks|key|3352568|text|因为没有人提到过这个…|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3352569|在不同的JVM之间比较System.nanoTime()调用的结果是不安全的，因为每个JVM可能有一个独立的“起始”时间。|offset|length|style|CODE|3352570|System.currentTimeMillis()将在JVM之间返回(近似)相同的值，因为它与系统挂钟时间相关。|3352571|如果您想要计算两个事件(如秒表)之间经过的时间量，请使用nanoTime()；系统挂钟中的更改会使currentTimeMillis()在此用例中不正确。|3352572|entityMap^0|0|B|H|0|0|Q|0|S|A|1D|J|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@$D|S|E|T|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|M|$]]

Since no one else has mentioned this…
It is not safe to compare the results of <code>System.nanoTime()</code> calls between different JVMs, each JVM may have an independent 'origin' time.
<code>System.currentTimeMillis()</code> will return the (approximate) same value between JVMs, because it is tied to the system wall clock time.
If you want to compute the amount of time that has elapsed between two events, like a stopwatch, use <code>nanoTime()</code>; changes in the system wall-clock make <code>currentTimeMillis()</code> incorrect for this use case.

blocks|key|3139769|text|这里的一件事是，nanoTime+method.it的不一致性并不能给出非常一致的值，因为相同的input.currentTimeMillis在性能和一致性方面要好得多，而且，尽管没有nanoTime那么精确，但误差范围更小，因此其值更准确。因此，我建议您使用currentTimeMillis|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3139770|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

one thing here is the inconsistency of the nanoTime method.it does not give very consistent values for the same input.currentTimeMillis does much better in terms of performance and consistency,and also ,though not as precise as nanoTime,has a lower margin of error,and therefore more accuracy in its value. i would therefore suggest that you use currentTimeMillis

blocks|key|358589|text|正如其他人所说，currentTimeMillis是时钟时间，由于夏令时(不是:夏令时和时区与currentTimeMillis无关，其余的都是真的)、用户更改时间设置、闰秒和互联网时间同步而改变。如果您的应用程序依赖于单调递增的运行时间值，那么您可能更喜欢nanoTime。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|358590|你可能会认为玩家在玩游戏时不会摆弄时间设置，也许你是对的。但不要低估互联网时间同步或远程桌面用户造成的干扰。nanoTime应用编程接口不会受到这种干扰的影响。|358591|如果您想使用时钟时间，但又要避免由于互联网时间同步而造成的中断，您可以考虑使用NTP客户端，例如Meinberg，它会将时钟频率调到零，而不是定期重新设置时钟。|358592|我是从个人经验说的。在我开发的一个天气应用程序中，我得到了随机出现的风速峰值。我花了一段时间才意识到，我的时基被一台典型PC上的时钟时间行为打乱了。当我开始使用nanoTime时，我所有的问题都消失了。一致性(单调性)对我的应用程序来说比原始精度或绝对精度更重要。|358593|entityMap^0|11|11|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|S|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|M|$]]

As others have said, currentTimeMillis is clock time, which changes due to daylight saving time (not: daylight saving &amp; time zone are unrelated to currentTimeMillis, the rest is true), users changing the time settings, leap seconds, and internet time sync. If your app depends on monotonically increasing elapsed time values, you might prefer nanoTime instead.
You might think that the players won't be fiddling with the time settings during game play, and maybe you'd be right. But don't underestimate the disruption due to internet time sync, or perhaps remote desktop users. The nanoTime API is immune to this kind of disruption.
If you want to use clock time, but avoid discontinuities due to internet time sync, you might consider an NTP client such as Meinberg, which &quot;tunes&quot; the clock rate to zero it in, instead of just resetting the clock periodically.
I speak from personal experience. In a weather application that I developed, I was getting randomly occurring wind speed spikes. It took a while for me to realize that my timebase was being disrupted by the behavior of clock time on a typical PC. All my problems disappeared when I started using nanoTime. Consistency (monotonicity) was more important to my application than raw precision or absolute accuracy.

blocks|key|3352726|text|对于游戏图形和平滑的位置更新，使用System.nanoTime()而不是System.currentTimeMillis()。我在一个游戏中从currentTimeMillis()切换到nanoTime()，并在运动流畅性方面获得了重大的视觉改进。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3352727|虽然一毫秒看起来似乎已经很精确了，但在视觉上却并非如此。nanoTime()可以改进的因素包括：|3352728|在挂钟resolution|3352729|ability下精确定位像素以消除像素之间的锯齿，如果您想要|unordered-list-item|3352730|
|3352731|Windows挂钟抖动(挂钟实际向前跳动的时间不一致)|3352732|3352733|正如其他答案所建议的那样，如果重复调用nanoTime，确实会有性能成本--最好每帧只调用一次，并使用相同的值来计算整个帧。|3352734|entityMap^0|H|H|11|Q|0|S|A|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|13|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|L|7|16|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|17|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|18|8|@]|D|@]|E|$]]|$1|T|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|U|$]]

For game graphics &amp; smooth position updates, use <code>System.nanoTime()</code> rather than <code>System.currentTimeMillis()</code>. I switched from currentTimeMillis() to nanoTime() in a game and got a major visual improvement in smoothness of motion.

While one millisecond may seem as though it should already be precise, visually it is not. The factors <code>nanoTime()</code> can improve include:

<ul>
<li>accurate pixel positioning below wall-clock resolution</li>
<li>ability to anti-alias between pixels, if you want</li>
<li>Windows wall-clock inaccuracy</li>
<li>clock jitter (inconsistency of when wall-clock actually ticks forward)</li>
</ul>

As other answers suggest, nanoTime does have a performance cost if called repeatedly -- it would be best to call it just once per frame, and use the same value to calculate the entire frame.

blocks|key|356113|text|System.currentTimeMillis()对于已用时间是不安全的，因为这种方法对系统的实时时钟变化很敏感。您应该使用System.nanoTime。请参考Java系统帮助：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|356114|关于nanoTime方法：|356115|356116|+..此方法提供纳秒精度，但不一定是纳秒分辨率(即，值更改的频率)-除了分辨率至少与currentTimeMillis()一样好之外，没有任何保证。|blockquote|356117|356118|356119|如果你使用System.currentTimeMillis()，你的运行时间可能是负的(返回<--到未来)|356120|entityMap^0|0|Q|1R|F|0|0|0|0|0|0|5|Q|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|Y|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|10|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|Q|$]]

<code>System.currentTimeMillis()</code> is not safe for elapsed time because this method is sensitive to the system realtime clock changes of the system. 
You should use <code>System.nanoTime</code>.
Please refer to Java System help:

About nanoTime method:

<blockquote>
 .. This method provides nanosecond precision, but not necessarily
 nanosecond resolution (that is, how frequently the value changes) - no
 guarantees are made except that the resolution is at least as good as
 that of currentTimeMillis()..
</blockquote>

If you use <code>System.currentTimeMillis()</code> your elapsed time can be negative (Back &lt;-- to the future)

<h2>Accuracy Vs. Precision</h2>

What I would like to know is whether I should use System.currentTimeMillis() or System.nanoTime() when updating my object's positions in my game? Their change in movement is directly proportional to the elapsed time since the last call and I want to be as precise as possible.

I've read that there are some serious time-resolution issues between different operating systems (namely that Mac / Linux have an almost 1 ms resolution while Windows has a 50ms resolution??). I'm primarly running my apps on windows and 50ms resolution seems pretty inaccurate.

Are there better options than the two I listed?

Any suggestions / comments?

System.currentTimeMillis vs System.nanoTime

Windows

Linux

Java

精度与Precision我想知道的是，当我在游戏中更新对象的位置时，我应该使用System.currentTimeMillis()还是System.nanoTime()？他们的移动变化与自上次调用以来所经过的时间成正比，我希望尽可能精确。我读到过，不同操作系统之间存在一些严重的时间分辨率问题(即Mac / Linux的...

问System.currentTimeMillis vs System.nanoTime
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问System.currentTimeMillis vs System.nanoTimeEN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问System.currentTimeMillis vs System.nanoTime
EN