Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8266847

Add java.time.InstantSource

    XMLWordPrintable

    Details

    • Type: CSR
    • Status: Closed
    • Priority: P4
    • Resolution: Approved
    • Fix Version/s: 17
    • Component/s: core-libs
    • Labels:
      None
    • Subcomponent:
    • Compatibility Risk:
      minimal
    • Compatibility Risk Description:
      Hide
      A new interface in `java.time` should not cause any source or binary incompatibility. The methods on `InstantSource` already exist on `Clock` with the same semantics.

      There are no impacts on serialization. The new interface does not extends `Serializable`, and existing implementations are unaffected by the addition.
      Show
      A new interface in `java.time` should not cause any source or binary incompatibility. The methods on `InstantSource` already exist on `Clock` with the same semantics. There are no impacts on serialization. The new interface does not extends `Serializable`, and existing implementations are unaffected by the addition.
    • Interface Kind:
      Java API
    • Scope:
      SE

      Description

      Summary

      Add java.time.InstantSource, an interface that provides the current instant. This will be an abstraction from java.time.Clock that only focuses on the current instant and does not refer to the time zone.

      Problem

      Since java.time was first added in Java 8, it has become apparent that there is a missing concept - a source of Instant independent of time zone. Put simply, if the only thing you want is an Instant, then Clock isn't the right API because it forces you to think about time zones.

      A good architectural design for time-based code would have a separation between the abstraction of the OS clock (dependency injected for unit testing), and the time zone linked to user localization. Passing these two things around separately is key. To achieve this as it stands, developers must either write their own TimeSource or InstantSource interface, or use Clock and "hold their nose" to ignore the time zone held within.

      A Supplier<Instant> obviously performs similar functionality, but it lacks discoverability and understandability. Plus, injecting generified interfaces tends to be painful.

      Solution

      It is intended to add a new interface InstantSource that provides the missing abstraction. While most systems would name this TimeSource, java.time is very specific in reducing use of the word "time" given its multiple/unclear meaning in the design space. An InstantSource that supplies an Instant is unambiguous.

      The proposed change is to add the new interface, implement it by Clock and add a new factory method to Clock that accepts an instantSource. All other uses of the new interface would be outside the JDK.

      JDK mailing list: - https://mail.openjdk.java.net/pipermail/core-libs-dev/2021-May/077213.html

      See this ThreeTen-Extra discussion: - https://github.com/ThreeTen/threeten-extra/issues/150

      Joda-Time has a MillisProvider that is similar: - https://www.joda.org/joda-time/apidocs/org/joda/time/DateTimeUtils.MillisProvider.html

      Time4J has a TimeSource: - https://github.com/MenoData/Time4J/blob/master/base/src/main/java/net/time4j/base/TimeSource.java

      Spring has a DateTimeContext that separates the user localization as per the UserContext described above: - https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/format/datetime/standard/DateTimeContext.html

      There is a similar concept TimeSource in sun.net.httpserver

      Specification

      InstantSource: (mostly cut and paste from Clock)

      /**
       * Provides access to the current instant.
       * <p>
       * Instances of this interface are used to access a pluggable representation of the current instant.
       * For example, {@code InstantSource} can be used instead of {@link System#currentTimeMillis()}.
       * <p>
       * The primary purpose of this abstraction is to allow alternate instant sources to be
       * plugged in as and when required. Applications use an object to obtain the
       * current time rather than a static method. This can simplify testing.
       * <p>
       * As such, this interface does not guarantee the result actually represents the current instant
       * on the time-line. Instead, it allows the application to provide a controlled view as to what
       * the current instant is.
       * <p>
       * Best practice for applications is to pass an {@code InstantSource} into any method
       * that requires the current instant. A dependency injection framework is one
       * way to achieve this:
       * <pre>
       *  public class MyBean {
       *    private InstantSource source;  // dependency inject
       *    ...
       *    public void process(Instant endInstant) {
       *      if (source.instant().isAfter(endInstant) {
       *        ...
       *      }
       *    }
       *  }
       * </pre>
       * This approach allows an alternative source, such as {@link #fixed(Instant) fixed}
       * or {@link #offset(InstantSource, Duration) offset} to be used during testing.
       * <p>
       * The {@code system} factory method provides a source based on the best available
       * system clock. This may use {@link System#currentTimeMillis()}, or a higher
       * resolution clock if one is available.
       *
       * @implSpec
       * This interface must be implemented with care to ensure other classes operate correctly.
       * All implementations must be thread-safe - a single instance must be capable of be invoked
       * from multiple threads without negative consequences such as race conditions.
       * <p>
       * The principal methods are defined to allow the throwing of an exception.
       * In normal use, no exceptions will be thrown, however one possible implementation would be to
       * obtain the time from a central time server across the network. Obviously, in this case the
       * lookup could fail, and so the method is permitted to throw an exception.
       * <p>
       * The returned instants from {@code InstantSource} work on a time-scale that ignores leap seconds,
       * as described in {@link Instant}. If the implementation wraps a source that provides leap
       * second information, then a mechanism should be used to "smooth" the leap second.
       * The Java Time-Scale mandates the use of UTC-SLS, however implementations may choose
       * how accurate they are with the time-scale so long as they document how they work.
       * Implementations are therefore not required to actually perform the UTC-SLS slew or to
       * otherwise be aware of leap seconds.
       * <p>
       * Implementations should implement {@code Serializable} wherever possible and must
       * document whether or not they do support serialization.
       *
       * @implNote
       * The implementation provided here is based on the same underlying system clock
       * as {@link System#currentTimeMillis()}, but may have a precision finer than
       * milliseconds if available.
       * However, little to no guarantee is provided about the accuracy of the
       * underlying system clock. Applications requiring a more accurate system clock must
       * implement this abstract class themselves using a different external system clock,
       * such as an NTP server.
       *
       * @since 17
       */
      public interface InstantSource {
      
          /**
           * Obtains a source that returns the current instant using the best available
           * system clock.
           * <p>
           * This source is based on the best available system clock. This may use
           * {@link System#currentTimeMillis()}, or a higher resolution system clock if
           * one is available.
           * <p>
           * The returned implementation is immutable, thread-safe and
           * {@code Serializable}.
           *
           * @return a source that uses the best available system clock, not null
           */
          static InstantSource system() { ... }
      
          //-------------------------------------------------------------------------
          /**
           * Obtains a source that returns instants from the specified source truncated to
           * the nearest occurrence of the specified duration.
           * <p>
           * This source will only tick as per the specified duration. Thus, if the
           * duration is half a second, the source will return instants truncated to the
           * half second.
           * <p>
           * The tick duration must be positive. If it has a part smaller than a whole
           * millisecond, then the whole duration must divide into one second without
           * leaving a remainder. All normal tick durations will match these criteria,
           * including any multiple of hours, minutes, seconds and milliseconds, and
           * sensible nanosecond durations, such as 20ns, 250,000ns and 500,000ns.
           * <p>
           * A duration of zero or one nanosecond would have no truncation effect. Passing
           * one of these will return the underlying source.
           * <p>
           * Implementations may use a caching strategy for performance reasons. As such,
           * it is possible that the start of the requested duration observed via this
           * source will be later than that observed directly via the underlying source.
           * <p>
           * The returned implementation is immutable, thread-safe and
           * {@code Serializable} providing that the base source is.
           *
           * @param baseSource  the base source to base the ticking source on, not null
           * @param tickDuration  the duration of each visible tick, not negative, not null
           * @return a source that ticks in whole units of the duration, not null
           * @throws IllegalArgumentException if the duration is negative, or has a
           *  part smaller than a whole millisecond such that the whole duration is not
           *  divisible into one second
           * @throws ArithmeticException if the duration is too large to be represented as nanos
           */
          static InstantSource tick(InstantSource baseSource, Duration tickDuration) { ... }
      
          //-----------------------------------------------------------------------
          /**
           * Obtains a source that always returns the same instant.
           * <p>
           * This source simply returns the specified instant.
           * As such, it is not a source that represents the current instant.
           * The main use case for this is in testing, where the fixed source ensures
           * tests are not dependent on the current source.
           * <p>
           * The returned implementation is immutable, thread-safe and {@code Serializable}.
           *
           * @param fixedInstant  the instant to use, not null
           * @return a source that always returns the same instant, not null
           */
          static InstantSource fixed(Instant fixedInstant) { ... }
      
          //-------------------------------------------------------------------------
          /**
           * Obtains a source that returns instants from the specified source with the
           * specified duration added.
           * <p>
           * This source wraps another source, returning instants that are later by the
           * specified duration. If the duration is negative, the instants will be
           * earlier than the current date and time.
           * The main use case for this is to simulate running in the future or in the past.
           * <p>
           * A duration of zero would have no offsetting effect.
           * Passing zero will return the underlying source.
           * <p>
           * The returned implementation is immutable, thread-safe and {@code Serializable}
           * providing that the base source is.
           *
           * @param baseSource  the base source to add the duration to, not null
           * @param offsetDuration  the duration to add, not null
           * @return a source based on the base source with the duration added, not null
           */
          static InstantSource offset(InstantSource baseSource, Duration offsetDuration) { ... }
      
          //-----------------------------------------------------------------------
          /**
           * Gets the current instant of the source.
           * <p>
           * This returns an instant representing the current instant as defined by the source.
           *
           * @return the current instant from this source, not null
           * @throws DateTimeException if the instant cannot be obtained, not thrown by most implementations
           */
          Instant instant();
      
          //-------------------------------------------------------------------------
          /**
           * Gets the current millisecond instant of the source.
           * <p>
           * This returns the millisecond-based instant, measured from 1970-01-01T00:00Z (UTC).
           * This is equivalent to the definition of {@link System#currentTimeMillis()}.
           * <p>
           * Most applications should avoid this method and use {@link Instant} to represent
           * an instant on the time-line rather than a raw millisecond value.
           * This method is provided to allow the use of the source in high performance use cases
           * where the creation of an object would be unacceptable.
           *
           * @implSpec
           * The default implementation calls {@link #instant()}.
           *
           * @return the current millisecond instant from this source, measured from
           *  the Java epoch of 1970-01-01T00:00Z (UTC), not null
           * @throws DateTimeException if the instant cannot be obtained, not thrown by most implementations
           */
          default long millis() { ... }
      
          //-----------------------------------------------------------------------
          /**
           * Returns a clock with the specified time-zone.
           * <p>
           * This returns a {@link Clock}, which is an extension of this interface
           * that combines this source and the specified time-zone.
           * <p>
           * The returned implementation is immutable, thread-safe and {@code Serializable}
           * providing that this source is.
           *
           * @implSpec
           * The default implementation returns an immutable, thread-safe and
           * {@code Serializable} subclass of {@link Clock} that combines this
           * source and the specified zone.
           *
           * @param zone  the time-zone to use, not null
           * @return a clock based on this source with the specified time-zone, not null
           */
          default Clock withZone(ZoneId zone) { ... }
      
      }

      Clock class-level spec:

      • Clarify wording in best practice (add "and time-zone")
      • Extra paragraph "related to ..."
      • Remove implSpec/implNote as these are now on the interface
      • Make Clock implement InstantSource

      see attachment

        Attachments

        1. diff.txt
          4 kB
        2. JDK-8266847-diff.txt
          4 kB
        3. JDK-8266847-diff-v2.txt
          34 kB
        4. JDK-8266847-diff-v3.txt
          37 kB
        5. JDK-8266847-diff-v4.txt
          38 kB

          Issue Links

            Activity

              People

              Assignee:
              scolebourne Stephen Colebourne
              Reporter:
              scolebourne Stephen Colebourne
              Reviewed By:
              Naoto Sato, Roger Riggs
              Votes:
              0 Vote for this issue
              Watchers:
              2 Start watching this issue

                Dates

                Created:
                Updated:
                Resolved: