java.time.Instant 是如何计算纳秒的？

Question

The Java 8 docs on java.time.Instant state:

The range of an instant requires the storage of a number larger than a long. To achieve this, the class stores a long representing epoch-seconds and an int representing nanosecond-of-second, which will always be between 0 and 999,999,999.

As per the System.currentTimeMillis() documentation , the Java 8 clock only guarantees, at best, millisecond resolution:

Note that while the unit of time of the return value is a millisecond, the accuracy of the value depends on the underlying operating system and may be larger

If Java 8 only guarantees millisecond accuracy at best, how does Java calculate the java.time.Instant nanosecond-of-second value?

Answer 1

The Instant class just promises nanosecond precision (ie the value of nanos will be provided in nanoseconds ). It does not promise nanosecond accuracy (ie the value may not accurately represent the current number of nanoseconds).

A simple multiplier (as specified by the specific SystemClock class instance used) is all that is needed to convert whatever unit can be obtained to nanoseconds.

---

Other points:

The System.currentTimeMillis method's documentation you link does not say 'at best'; it just promises to do as well as it can.

Secondly, you can see the implementation of the method by following through the stack trace in (for example) Instant.now() . On my machine's java 8 setup (Mac OS, JDK 1.8.0.241) this falls back to using the SystemClock class, which eventually uses System.currentTimeMillis() and Instant.ofEpochMillis . In that method, you can see that it simply multiplies the 'epoch millis' by 1_000_000 .

This has changed in later versions of java however.

Answer 2

Java uses Clock class to get current instant. Clock.systemUTC() return best available system clock instance which could return more precise timestamp.

That said, Java 8 on Windows uses System.currentTimeMillis() as a source so it returns millisecond-precise time. But that's not guaranteed and other implementations can provide more precise time.

Also note that Instant is not necessarily obtained by Instant.now() call. You can parse it from input data, for example, where nanosecond precision might be useful.