Новости из мира ПК
4 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд

System currenttimemillis java

Java System.nanoTime () против System.currentTimeMillis

Java предоставляет два метода для измерения времени, System.nanoTime () и System.currentTimeMillis (). Но какой из них следует использовать в каких условиях? И что более эффективно?

На первый взгляд может показаться, что следует использовать nanoTime (), поскольку он дает более точное значение времени (в нано секундах по сравнению с миллисекундами, которые возвращает другой метод). Но всегда ли эффективно на процессоре использовать nanoTime? Давайте посмотрим на плюсы и минусы использования обоих методов:

System.currentTimeMillis ()


  1. Это потокобезопасно . Потоковая безопасность означает, что если этот метод вызывается между двумя или более различными потоками, он не будет возвращать ошибочные результаты.
  2. Всегда возвращает абсолютное время, прошедшее с начала эпохи (количество миллисекунд с 1 января 1970 г. 00:00).
  3. Потребляет меньше тактов для выполнения (около 5-6 тактовых процессоров).
  4. Дает более точное время, так как точка отсчета (эпоха) является фиксированной.


  1. Менее точно . Результат где-то между 1/1000-й / 15/1000-й секунды. На некоторых машинах разрешение даже меньше 50 мс и может снизиться только до 10 мс.
  2. Это может дать неправильные результаты, если пользователь изменяет системное время, делает скачок в секунду или происходят изменения в синхронизации NTP.

System.nanoTime ()


  1. Очень точный Время возврата составляет около 1/1000000-й секунды.
  2. Разрешение намного выше, чем currentTimeMillis () .


  1. Отраженный результат не имеет фиксированной контрольной точки. Согласно документации Java,
  2. Менее точный . Этот метод обеспечивает точность наносекунды, но не обязательно точность наносекунды. Нет никаких гарантий относительно того, как часто меняются значения.
  3. В зависимости от системы может потребоваться более 100 циклов процессора.
  4. Не потокобезопасен . Может возвращать ошибочные результаты, если используется между несколькими потоками.
Читать еще:  Java runtime exec

Давайте посмотрим на рабочий пример, чтобы сравнить результаты этих двух функций:

// Java-программа для иллюстрации
// разница между
// Java System.nanoTime ()
// и System.currentTimeMillis

public static void main(String[] args)

// Получить текущее системное время в

// и нано и миллисекунды до

long nano_startTime = System.nanoTime();

long millis_startTime = System.currentTimeMillis();

// Выполнить работу, время которой нужно измерить

// Получить текущее системное время в обоих

System.currentTimeMillis vs System.nanoTime

Accuracy Vs. Precision

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?

10 Answers 10

If you’re just looking for extremely precise measurements of elapsed time, use System.nanoTime() . System.currentTimeMillis() will give you the most accurate possible elapsed time in milliseconds since the epoch, but System.nanoTime() gives you a nanosecond-precise time, relative to some arbitrary point.

From the Java Documentation:

Returns the current value of the most precise available system timer, in nanoseconds.

This method can only be used to measure elapsed time and is not related to any other notion of system or wall-clock time. The value returned represents nanoseconds since some fixed but arbitrary origin time (perhaps in the future, so values may be negative). This method provides nanosecond precision, but not necessarily nanosecond accuracy. No guarantees are made about how frequently values change. Differences in successive calls that span greater than approximately 292 years (2 63 nanoseconds) will not accurately compute elapsed time due to numerical overflow.

Читать еще:  Предельная ошибка выборки равна

For example, to measure how long some code takes to execute:

Since no one else has mentioned this…

It is not safe to compare the results of System.nanoTime() calls between different threads. Even if the events of the threads happen in a predictable order, the difference in nanoseconds can be positive or negative.

System.currentTimeMillis() is safe for use between threads.

Update by Arkadiy: I’ve observed more correct behavior of System.currentTimeMillis() 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.

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 System.currentTimeMillis() and System.nanoTime() ), when you would want to use which, and how they work internally.

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 Thread.sleep() will cause this resolution change.

System.nanoTime() isn’t supported in older JVMs. If that is a concern, stick with currentTimeMillis

Regarding accuracy, you are almost correct. On SOME Windows machines, currentTimeMillis() 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 GAGETimer in the past with moderate success.

Читать еще:  Случайные ошибки измерения подчинены нормальному закону

As others have said, currentTimeMillis is clock time, which changes due to daylight saving time, 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 «tunes» 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.

Ссылка на основную публикацию