Monotonic sorting for UUID Variant 7

Author: Hellblazer

src/main/java/com/fasterxml/uuid/Generators.java

@@ -128,10 +128,8 @@ public static TimeBasedEpochGenerator timeBasedEpochGenerator()
 
     /**
      * Factory method for constructing UUID generator that generates UUID using
-     * variant 7 (time+random based), using specified Ethernet address
-     * as the location part of UUID.
-     * No additional external synchronization is used.
-     */
+     * variant 7 (Unix Epoch time+random based).
+    */
     public static TimeBasedEpochGenerator timeBasedEpochGenerator(Random random)
     {
         return new TimeBasedEpochGenerator(random);

src/main/java/com/fasterxml/uuid/impl/TimeBasedEpochGenerator.java

@@ -3,8 +3,10 @@
 import java.security.SecureRandom;
 import java.util.Random;
 import java.util.UUID;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
-import com.fasterxml.uuid.NoArgGenerator; 
+import com.fasterxml.uuid.NoArgGenerator;
 import com.fasterxml.uuid.UUIDType;
 
 /**
@@ -22,7 +24,9 @@
  * @since 4.1
  */
 public class TimeBasedEpochGenerator extends NoArgGenerator
-{
+{ 
+    private static final int ENTROPY_BYTE_LENGTH = 10;
+
     /*
     /**********************************************************************
     /* Configuration
@@ -33,6 +37,9 @@ public class TimeBasedEpochGenerator extends NoArgGenerator
      * Random number generator that this generator uses.
      */
     protected final Random _random;
+    private long _lastTimestamp = -1;
+    private final byte[] _lastEntropy  = new byte[ENTROPY_BYTE_LENGTH];
+    private final Lock lock = new ReentrantLock();
 
     /*
     /**********************************************************************
@@ -69,25 +76,34 @@ public TimeBasedEpochGenerator(Random rnd)
     /* UUID generation
     /**********************************************************************
      */
-
+    
     @Override
     public UUID generate()
     {
-        final long rawTimestamp = System.currentTimeMillis();
-        final byte[] rnd = new byte[10];
-        _random.nextBytes(rnd);
-
-        // Use only 48 lowest bits as per spec, next 16 bit from random
-        // (note: UUIDUtil.constuctUUID will add "version" so it's only 12
-        // actual random bits)
-        long l1 = (rawTimestamp << 16) | _toShort(rnd, 8);
-
-        // And then the other 64 bits of random; likewise UUIDUtil.constructUUID
-        // will overwrite first 2 random bits so it's "only" 62 bits
-        long l2 = _toLong(rnd, 0);
-
-        // and as per above, this call fills in "variant" and "version" bits
-        return UUIDUtil.constructUUID(UUIDType.TIME_BASED_EPOCH, l1, l2);
+        lock.lock();
+        try { 
+            long rawTimestamp = System.currentTimeMillis();
+            if (rawTimestamp == _lastTimestamp) {
+                boolean c = true;
+                for (int i = ENTROPY_BYTE_LENGTH - 1; i >= 0; i--) {
+                    if (c) {
+                        byte temp = _lastEntropy[i];
+                        temp = (byte) (temp + 0x01);
+                        c = _lastEntropy[i] == (byte) 0xff && c;
+                        _lastEntropy[i] = temp;
+                    }
+                }
+                if (c) {
+                    throw new IllegalStateException("overflow on same millisecond");
+                }
+            } else {
+                _lastTimestamp = rawTimestamp;
+                _random.nextBytes(_lastEntropy);
+            }
+            return UUIDUtil.constructUUID(UUIDType.TIME_BASED_EPOCH, (rawTimestamp << 16) | _toShort(_lastEntropy, 0), _toLong(_lastEntropy, 2));
+        } finally {
+            lock.unlock();
+        }
     }
 
     /*

src/test/java/com/fasterxml/uuid/UUIDComparatorTest.java

@@ -14,8 +14,14 @@
  */
 package com.fasterxml.uuid;
 
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Random;
 import java.util.UUID;
 
+import com.fasterxml.uuid.impl.TimeBasedEpochGenerator;
+
 import junit.framework.TestCase;
 
 public class UUIDComparatorTest
@@ -100,4 +106,24 @@ public void testSorting()
             }
         }
     }
+
+    public void testSortingMV7() throws Exception {
+        final int count = 10000000;
+        Random entropy = new Random(0x666); 
+        final TimeBasedEpochGenerator generator = Generators.timeBasedEpochGenerator(entropy);
+        List<UUID> created = new ArrayList<UUID>(count);
+        for (int i = 0; i < count; i++) {
+            created.add(generator.generate());
+        }
+        List<UUID> sortedUUID = new ArrayList<UUID>(created);
+        sortedUUID.sort(new UUIDComparator());
+        HashSet<UUID> unique = new HashSet<UUID>(count);
+        
+        for (int i = 0; i < created.size(); i++) {
+            assertEquals("Error at: " + i, created.get(i), sortedUUID.get(i));
+            if (!unique.add(created.get(i))) {
+                System.out.println("Duplicate at: " + i);
+            }
+        }
+    }
 }

src/test/java/com/fasterxml/uuid/UUIDGeneratorTest.java

@@ -250,13 +250,15 @@ public void testV7value()
      * Test of generateTimeBasedEpochUUID() method,
      * of class com.fasterxml.uuid.UUIDGenerator.
      */
-    public void testGenerateTimeBasedEpochUUID()
+    public void testGenerateTimeBasedEpochUUID() throws Exception
     {
         // this test will attempt to check for reasonable behavior of the
         // generateTimeBasedUUID method
+        
+        Random entropy = new Random(0x666);
 
         // we need a instance to use
-        TimeBasedEpochGenerator uuid_gen = Generators.timeBasedEpochGenerator();
+        TimeBasedEpochGenerator uuid_gen = Generators.timeBasedEpochGenerator(entropy);
 
         // first check that given a number of calls to generateTimeBasedEpochUUID,
         // all returned UUIDs order after the last returned UUID
@@ -268,14 +270,16 @@ public void testGenerateTimeBasedEpochUUID()
 
         // before we generate all the uuids, lets get the start time
         long start_time = System.currentTimeMillis();
+        Thread.sleep(2);  // Clean start time
 
         // now create the array of uuids
         for (int i = 0; i < uuid_array.length; i++) {
             uuid_array[i] = uuid_gen.generate();
         }
-
+ 
         // now capture the end time
         long end_time = System.currentTimeMillis();
+        Thread.sleep(2);  // Clean end time
 
         // check that none of the UUIDs are null
         checkUUIDArrayForNonNullUUIDs(uuid_array);
@@ -284,7 +288,7 @@ public void testGenerateTimeBasedEpochUUID()
         checkUUIDArrayForCorrectVariantAndVersion(uuid_array, UUIDType.TIME_BASED_EPOCH);
 
         // check that all the uuids were generated with correct order
-//        checkUUIDArrayForCorrectOrdering(uuid_array);
+        checkUUIDArrayForCorrectOrdering(uuid_array);
 
         // check that all uuids were unique
         checkUUIDArrayForUniqueness(uuid_array);
@@ -757,26 +761,22 @@ private void checkUUIDArrayForCorrectCreationTimeReorder(UUID[] uuidArray,
         }
     }
 
-    // Modified version for Variant 7 (Unix Epoch timestamps)
+    // Modified version for Variant 7 (Unix Epoch monotonic timestamps)
     private void checkUUIDArrayForCorrectCreationTimeEpoch(UUID[] uuidArray,
             long startTime, long endTime)
     {
-
-        // 21-Feb-2020, tatu: Not sure why this would be checked, as timestamps come
-        // from
-        // System.currenTimeMillis()...
         assertTrue("Start time: " + startTime + " was after the end time: " + endTime, startTime <= endTime);
 
         // let's check that all uuids in the array have a timestamp which lands
         // between the start and end time
         for (int i = 0; i < uuidArray.length; i++) {
             byte[] temp_uuid = UUIDUtil.asByteArray(uuidArray[i]);
             ByteBuffer buff = ByteBuffer.wrap(temp_uuid);
-            long uuid_time = buff.getLong() >>> 16;
+            final long uuid_time = buff.getLong() >>> 16; 
             // now check that the times are correct
             assertTrue("Start time: " + startTime + " was not before UUID timestamp: " + uuid_time,
                        startTime <= uuid_time);
-            assertTrue("UUID timestamp: " + uuid_time + " was not before the end time: " + endTime,
+            assertTrue("UUID: " + i + " timestamp: " + uuid_time + " was not before the end time: " + endTime,
                        uuid_time <= endTime);
         }
     }