Generating Unique Numeric IDs using DateTime.Now.Ticks

Question

I need to generate a unique numeric ID to attach to an incoming request. This ID is used only temporarily to track the request and will be discarded once the request has completed processing. This ID will only be used in the context of this application but will need to be assigned in a high performance multi-threaded way.

I was thinking of using DateTime.Now.Ticks for this ID but would like to know if DateTime.Now.Ticks could still generate a colliding ID if simultaneous requests are being concurrently being processed?

If anyone could suggest a better way to generate these IDs (preferably one that is not Int64 like Tick is) in a multi-threaded environment, please let me know. Something as simple as an incrementing number would suffice even, if only I didn't have to lock the number before incrementing.

Answer 1

You just need to use a static variable that is incremented each time you want another unique value. You can make this thread safe and still very fast by using the Interlocked.Increment method...

// Declaration
private static int safeInstanceCount = 0;

// Usage
{
      ...
      Interlocked.Increment(ref safeInstanceCount);
      ...
}

Answer 2

DateTime.Now is absolutely terrible for this purpose. At best, you'll have a resolution of 1 millisecond; at worst, 17 ms on NT and 1 second (!) on CE/Compact Framework.

Consider using Interlocked.Increment method for a fast, thread-safe counter.

Answer 3

Start with a per-thread ID (if multiple threads are originating the requests), concatenated with a per-thread counter (if each thread is expected to originate more than one request).

Answer 4

Just get a strong random number or use a GUID

• http://www.codeproject.com/KB/security/CryptoPasswordGenerator.aspx

• http://msdn.microsoft.com/en-us/library/system.random.aspx

• http://msdn.microsoft.com/en-us/library/system.guid.newguid.aspx

If high performance is the MUST have feature, allocate sequential numbers in monotonous sequence. Prevent lock contention by 'reserving' a range of (say, 20-100) ID's per thread that handles messages. That way, you'll need to lock the sequence generator only once in 20-100 iterations.

Answer 5

If you know how many threads you're going to have (or at least an upper bound), you can divide your ID space up between your threads, computing the ID as the value of a (thread local) counter and the thread's ID - eg, counter_value++ << 8 | thread_id. Thus, no coordination or locking between threads is required, and generating an ID requires only an increment, a bitshift, and an or.

If you use the system thread ID for this, your IDs will be slightly longer, but you don't need to manually assign IDs to your threads.

Answer 6

Can use this property but pay 1ms which is not important!

public static long UniqId { 
    get { 
        Thread.Sleep(1); 
        return long.Parse(DateTime.Now.ToString("yyMMddHHmmssffff")); 
    } 
}

Answer 7

I am using a simple generation Id based on time,It might help.

private static readonly string prefixNumber = ConfigManager.Current.GetAppSetting("AppTimeIdPrefix", "");
private static readonly DateTime epoch = DateTime.SpecifyKind(DateTime.Parse(ConfigManager.Current.GetAppSetting("AppTimeIdEpoch", "1970/01/01")), DateTimeKind.Utc);
/// <summary>
/// DateTime.Now is only updated every 10-15ms.
/// </summary>
private static long lastTime = CurrentTimeMilliseconds();
private static readonly object timeLock = new object();

private static long CurrentTimeMilliseconds()
{
   return (long)(DateTime.UtcNow.ToUniversalTime() - epoch).TotalMilliseconds;
}

public static long CreateId()
{
    lock (timeLock)
    { // prevent concurrent access to ensure uniqueness
        long original, newValue;
       do
      {
         original = lastTime;
         newValue = Math.Max(CurrentTimeMilliseconds(), original + 1);
      } while (Interlocked.CompareExchange(ref lastTime, newValue, original) != original);

        return long.Parse(string.Format("{0}{1}", prefixNumber, newValue));
     }
}

refer to How to ensure a timestamp is always unique?