FastTime a faster alternative to System.currentTimeMillis

FastTime is 100 times faster (according to my primitive
benchmark) than System.currentTimeMillis. It is less accurate.

pdb-utils/src/main/java/org/lucares/utils/FastTime.java

@@ -0,0 +1,81 @@
+package org.lucares.utils;
+
+import java.time.Duration;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Faster than {@link System#currentTimeMillis()}, but with a lower resolution.
+ */
+public class FastTime {
+    private static final class TimeUpdaterThread extends Thread {
+
+        private static final long UPDATE_INTERVAL = Duration.ofMillis(50).toMillis();
+
+        public TimeUpdaterThread() {
+            setDaemon(true);
+            setName("fast-time");
+        }
+
+        @Override
+        public void run() {
+            while (true) {
+                try {
+                    TimeUnit.MILLISECONDS.sleep(UPDATE_INTERVAL);
+                    currentTimeMillis = System.currentTimeMillis();
+                } catch (final InterruptedException e) {
+                    // interrupted -> abort
+                }
+            }
+        }
+    }
+
+    private volatile static long currentTimeMillis = System.currentTimeMillis();
+
+    static {
+        new TimeUpdaterThread().start();
+    }
+
+    public static long currentTimeMillis() {
+        return currentTimeMillis;
+    }
+
+    /**
+     * <pre>
+     * ---------------------------------------- 
+     * Benchmark:
+     * fastTime   took: 0.024366 ms -> sum = 162766570282900000
+     * timeMillis took: 2.587725 ms -> sum = 162766570283110644
+     * timeMillis / fastTime = 106.20229007633587
+     * </pre>
+     */
+
+    public static void main(final String[] args) {
+        for (int i = 0; i < 100; i++) {
+            final double f = fastTime();
+            final double t = timeMillis();
+            System.out.println("t / f = " + (t / f));
+        }
+    }
+
+    private static double fastTime() {
+        final long start = System.nanoTime();
+        long sum = 0;
+        for (int j = 0; j < 100000; j++) {
+            sum += FastTime.currentTimeMillis();
+        }
+        final double duration = (System.nanoTime() - start) / 1_000_000.0;
+        System.out.println("fastTime   took: " + duration + " ms -> sum = " + sum);
+        return duration;
+    }
+
+    private static double timeMillis() {
+        final long start = System.nanoTime();
+        long sum = 0;
+        for (int j = 0; j < 100000; j++) {
+            sum += System.currentTimeMillis();
+        }
+        final double duration = (System.nanoTime() - start) / 1_000_000.0;
+        System.out.println("timeMillis took: " + duration + " ms -> sum = " + sum);
+        return duration;
+    }
+}