Utilizing Epoch Time for Unique ID Generation Using Unsigned 32-Bit Integers

Photo by Donald Wu on Unsplash

In software development, unique identifiers (IDs) are essential for distinguishing records and managing data. In this guide we will explore how to use epoch time to generate unique IDs that fit within the constraints of an unsigned 32-bit integer. We will cover various approaches, their advantages and disadvantages, and a Kotlin code examples for each implementation will be provided, which you can test using the Kotlin Playground.

What is an Unsigned 32-Bit Integer?

An unsigned 32-bit integer is a type of number that can represent values from 0 to 4,294,967,295. Since we are working with epoch time, which can exceed this range over time, our goal is to ensure the IDs we generate stay within these bounds.

Different Ways to Generate Unique IDs

1. Truncation Method

This approach leverages the current epoch time in seconds, which exceeds the range of a 32-bit integer, by using only the lower 32 bits. This method is straightforward and provides a unique ID generated within a reasonable time frame.

Code Example

fun generateEpochId(): UInt {
    // Get current time in seconds and take the lower 32 bits
    val currentTime = System.currentTimeMillis() / 1000  // Epoch time in seconds
    return (currentTime and 0xFFFFFFFF).toUInt()  // Truncate to fit into UInt (32 bits)
}

fun main() {
    println("Generated ID: ${generateEpochId()}")
}

Pros:

• Simplicity: Very easy to implement, making it suitable for quick solutions.
• Low Resource Usage: Minimal computational resources required.

Cons:

• Collision Risk: IDs generated in the same second may be identical, especially in high-throughput systems.

2. Modulo Method

This approach uses the current epoch time in milliseconds and applies a modulo operation to ensure the resulting ID fits within the 32-bit unsigned integer range. This method is simple but requires careful handling of potential collisions.

Code Example

fun generateEpochId(): UInt {
    // Get the current time in milliseconds and fit it into an unsigned integer
    val currentTime = System.currentTimeMillis()
    return (currentTime % UInt.MAX_VALUE.toLong()).toUInt()
}

fun main() {
    println("Generated ID: ${generateEpochId()}")
}

Pros:

• Ease of Implementation: Straightforward to code and understand.
• Minimal Complexity: Simple logic without additional data structures.

Cons:

• Potential for Duplicates: Multiple IDs generated within the same millisecond could lead to duplicates.

3. Modulo + Randomness Method

This approach enhances the uniqueness of the ID by adding a random number to the current epoch time in milliseconds. The inclusion of randomness significantly reduces the likelihood of generating the same ID in rapid succession.

Code Example

import kotlin.random.Random

fun generateEpochId(): UInt {
    // Get the current time in milliseconds and add a random value
    val currentTime = System.currentTimeMillis()
    val randomPart = Random.nextInt(1000)  // Generates a random number between 0 and 999
    return ((currentTime + randomPart) % UInt.MAX_VALUE.toLong()).toUInt()
}

fun main() {
    println("Generated ID: ${generateEpochId()}")
}

Pros:

• Lower Collision Risk: Significantly reduces the chance of generating the same ID due to the added randomness.

Cons:

• Potential Overlap: If many IDs are generated simultaneously, there’s still a risk of collisions.

4. Modulo + Randomness + Counter Method

This approach further improves uniqueness by combining the current epoch time with both a random number and a counter. The counter increments with each call, helping to ensure that even rapid ID generations produce distinct values.

Code Example

import kotlin.random.Random

var counter = 0

fun generateEpochId(): UInt {
    val currentTime = System.currentTimeMillis()
    val randomPart = Random.nextInt(1000)  // Generates a random number
    counter = (counter + 1) % 1000  // Increment the counter and wrap around
    return ((currentTime + randomPart + counter) % UInt.MAX_VALUE.toLong()).toUInt()
}

fun main() {
    println("Generated ID: ${generateEpochId()}")
}

Pros:

• High Uniqueness: Offers a strong guarantee against ID collisions, making it suitable for high-throughput applications.

Cons:

• Increased Complexity: More complex to implement and requires careful management of the counter.

5. Hashing Method

This approach creates unique IDs by hashing the current epoch time along with additional unique information, such as a machine ID or user ID. This method produces a highly unique ID, especially when combined with proper unique data.

Code Example

import java.security.MessageDigest

fun generateEpochId(salt: String): UInt {
    val currentTime = System.currentTimeMillis().toString() + salt
    val hash = MessageDigest.getInstance("SHA-256").digest(currentTime.toByteArray())
    return hash.take(4).fold(0.toUInt()) { acc, byte -> acc shl 8 or byte.toUInt() }
}

fun main() {
    println("Generated ID: ${generateEpochId("kosher")}")
}

Pros:

• Very Low Collision Rate: Extremely unlikely to generate the same ID, especially with proper unique data.

Cons:

• Higher Computational Overhead: More resource-intensive due to hashing; may not be suitable for all applications.

Uniqueness Over Time

Short-term Uniqueness

This method is based on the current epoch time in milliseconds, which means that every millisecond will generate a different ID. As long as your system doesn’t generate multiple IDs in the exact same millisecond, this should guarantee uniqueness.

Collision Risk

However, if your system generates multiple IDs per millisecond, there is a risk of collisions because the epoch time is not fine-grained enough to differentiate between IDs generated within the same millisecond. In high-traffic systems, this might happen, leading to duplicate IDs.

Long-term Uniqueness

Using modulo (% UInt.MAX_VALUE) causes IDs to repeat every time the epoch time exceeds UInt.MAX_VALUE. Since the epoch time is in milliseconds, the wrap-around will occur approximately every 49.7 days (2^32 milliseconds = 49.7 days). This means that after 49.7 days, the IDs will start repeating unless you have additional measures in place to detect or prevent duplicates.

Randomness Doesn’t Guarantee Uniqueness After Wrap-Around

While the random part helps within short periods, over the long term (i.e., after 49.7 days), the IDs will start repeating. Even with the random component, there’s a chance of reusing previous IDs if enough time has passed.

Conclusion

Using epoch time to create unique IDs is a practical solution, especially when combined with random elements to reduce the risk of collisions. Depending on your application’s needs, you can choose from the methods discussed in this article to implement an effective unique ID system. The only downside is that it won’t guarantee uniqueness beyond 49.7 days due to the 32-bit UInt wrap-around.

Sample Use Cases

• Database primary keys.
• Transaction IDs in payment systems.
• Event logging.

Future Considerations

As your system scales, more advanced ID generation strategies may become necessary, particularly for databases or distributed systems. It’s crucial to choose an approach that aligns with your system’s current and future needs, ensuring long-term scalability and uniqueness.