sonyflake | A distributed unique ID generator inspired by Twitter | Theme library

If you mean 12 decimal digits, then you can use a number up to 39 bits (40 bits can represent 13-digit in addition to 12-digit numbers).

If you take 16 bits for the machine ID, and 8 bits for the data center ID, that leaves only 15 bits for the unique portion of the ID for that machine (so only 32768 unique numbers per machine.) With so few numbers, you can choose to assign the numbers sequentially rather than randomly.

If you mean 12 hexadecimal (base-16) digits, then the situation improves considerably: 16 bits makes up 4 digits and 8 bits makes up another two, leaving 6 base-16 digits for the unique portion of the ID, or 16,777,216 different numbers (24 bits). With this many numbers, you have several different choices to have each machine assign these numbers. You can do so sequentially, or at random (using java.security.SecureRandom, not java.util.Random), or using a timestamp with 10 ms resolution, as in Sonyflake.

It appears your question is less about how to generate a 12-digit unique ID than it is about how to format a number to fit in exactly 12 digits. Then you have two options. Assume you have a 39-bit integer x (less than 2³⁹ and so less than 10¹²).

• If you can accept leading zeros in the number, then do the following to format x to a 12-digit number:String.format("%012d", x).

• If you can't accept leading zeros in the number, then add 100000000000 (10¹¹) to x. Since x is less than 2³⁹, which is less than 900000000000, this will result in a 12-digit number.

You are generating worker IDs at random. In general, random numbers are not enough by themselves to ensure uniqueness. You need some way to check each worker ID you generate for uniqueness. Once you do so, each worker/datacenter pair will be unique. Thus, each machine is required only to generate a machine-unique number, which will be 25 bits long in your case. There are several ways to do so:

• The simplest way is to generate a random number or time-based number (using all 25 bits in your example) and check the number for uniqueness using a hash set (e.g., java.util.HashSet). If the number was already generated, try again with a new number. (Instead of a hash table, it may be more memory-efficient to use a bit set (e.g., java.util.BitSet) or a compressed bitmap (e.g., a "roaring bitmap").)

• Another way is to use a hash table with random/time-based numbers as keys and sequence IDs as values. When a unique number needs to be generated, do the following:

  1. Generate X, a random number or time-based number.
  2. Check whether a key equal to X is found in the hash table.
  3. If the key does not exist, create a new entry in the table, where the key is X and the value is 0. The unique number is X and a sequence number of 0. Stop.
  4. If the key exists, and the value associated with that key is less than 255, add 1 to the value. The unique number is X and a sequence number of that value. Stop.
  5. If the key exists, and the value associated with that key is 255 or greater, go to step 1.