System.currentTimeMillis() does not change after being packaged into a native image with GraalVM

[seepine]

public class CurrentTimeMillis {
    private volatile long now;

    private CurrentTimeMillis() {
        this.now = System.currentTimeMillis();
        this.scheduleTick();
    }

    private void scheduleTick() {
        (new ScheduledThreadPoolExecutor(1, (runnable) -> {
            Thread thread = new Thread(runnable, "tool-current-time-millis");
            thread.setDaemon(true);
            return thread;
        })).scheduleAtFixedRate(() -> {
            this.now = System.currentTimeMillis();
        }, 1L, 1L, TimeUnit.MILLISECONDS);
    }

    public static long now() {
        return getInstance().now;
    }

    private static CurrentTimeMillis getInstance() {
        return CurrentTimeMillis.SingletonHolder.INSTANCE;
    }

    private static class SingletonHolder {
        private static final CurrentTimeMillis INSTANCE = new CurrentTimeMillis();

        private SingletonHolder() {
        }
    }
}

CurrentTimeMillis.now() always returns the time when the native image was built successfully.

[quarkus-bot[bot]]

/cc @zakkak (native-image)

[zakkak]

Hi @seepine, this is not Quarkus specific. You can replicate it by adding a main method to CurrentTimeMillis and built it with:

javac CurrentTimeMillis.java
native-image --initialize-at-build-time=. CurrentTimeMillis

What happes here is that GraalVM's native-image initializes the class SingletonHolder at build time, which essentially invokes the CurrentTimeMillis constructor (at build-time) resulting in the executor updating now to only run at build time.

Typically this is solved by registering SingletonHolder for runtime (re)initialization.

[seepine]

@zakkak Thanks, can i replace with this ? and CurrentTime.milli()

public class CurrentTime {

  public static long startNanoTime = System.currentTimeMillis() * 1_000_000;
  public static long startNano = System.nanoTime();

  /**
   *
   * @return nano
   */
  public static long nano() {
    return startNanoTime + System.nanoTime() - startNano;
  }

  /**
   *
   * @return micro
   */
  public static long micro() {
    return nano() / 1_000;
  }

  /**
   *
   * @return milli
   */
  public static long milli() {
    return nano() / 1_000_000;
  }

  /**
   *
   * @return second
   */
  public static long second() {
    return nano() / 1_000_000_000;
  }

  public static LocalDateTime now() {
    Instant instant = Instant.ofEpochSecond(0, nano());
    return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
  }

}

[seepine]

I try it and build navite image , it can be work in my local docker , but the time was wrong in aws.

Test API

  @GET
  @Path("test")
  public JsonObject test() {
    return JsonObject.build()
      .set("CurrentTime.startNanoTime", CurrentTime.startNanoTime)
      .set("CurrentTime.startNano", CurrentTime.startNano)
      .set("CurrentTime.milli", CurrentTime.milli())
      .set("System.currentTimeMillis", System.currentTimeMillis())
      .set("CurrentTime.now", LocalDateTimeUtil.format(CurrentTime.now()))
      .set("LocalDateTime.now", LocalDateTimeUtil.format(LocalDateTime.now()));
  }

Docker run

docker run --rm -p 8080:8080 test:latest

Local api return

curl http://127.0.0.1:8080/test
{
    "CurrentTime.startNanoTime": 1701751703101000000,
    "CurrentTime.startNano": 640244974374,
    "CurrentTime.milli": 1701752800982,
    "System.currentTimeMillis": 1701752800983,
    "CurrentTime.now": "2023-12-05 13:06:40",
    "LocalDateTime.now": "2023-12-05 13:06:40"
}

Aws api return

curl http://example.com:8080/test
{
    "CurrentTime.startNanoTime": 1701751703101000000,
    "CurrentTime.startNano": 640244974374,
    "CurrentTime.milli": 1701891420956,
    "System.currentTimeMillis": 1701752119719,
    "CurrentTime.now": "2023-12-07 03:37:00",
    "LocalDateTime.now": "2023-12-05 12:55:19"
}

[zakkak]

@seepine please provide a complete Quarkus project as a reproducer along with the steps required to reproduce the issue.

[seepine]

@zakkak Thanks, it can work now that i modified it like this.

  private static long startNanoTime = 0;
  private static long startNano = 0;

  public static long nano() {
    if (startNanoTime == 0) {
      startNanoTime = System.currentTimeMillis() * 1_000_000;
    }
    if (startNano == 0) {
      startNano = System.nanoTime();
    }
    return startNanoTime + System.nanoTime() - startNano;
  }

Maybe the reason

When native image build done, the startNano and startNanoTime never change, and then CurremtTime.nano() the func exec System.nanoTime() that initial value change everytime

But this is my guess, after all, the native docker image can be work in my local.
Anyway, at least it can work for now.