വിതരണ സംവിധാനങ്ങളിൽ ഉപയോഗിക്കുന്ന 64-ബിറ്റ് ഐഡന്റിഫയർസ് ആയ ട്വിറ്റർ സ്നോഫ്ലേക്ക് ഐഡികൾ സൃഷ്ടിക്കുകയും അവയെ വിശകലനം ചെയ്യുകയും ചെയ്യുക. ഈ ഉപകരണം പുതിയ സ്നോഫ്ലേക്ക് ഐഡികൾ സൃഷ്ടിക്കാൻ നിങ്ങൾക്ക് അനുവദിക്കുന്നു, നിലവിലുള്ളവ പാഴ്സുചെയ്യുകയും ചെയ്യുന്നു, അവയുടെ ടൈംസ്റ്റാമ്പ്, മെഷീൻ ഐഡി, സീക്വൻസ് നമ്പർ ഘടകങ്ങൾ എന്നിവയിൽ അവലോകനങ്ങൾ നൽകുന്നു.
ഒരു സ്നോഫ്ലേക്ക് ഐഡി ജനറേറ്റർ വ്യാപിതമായ സംവിധാനങ്ങൾക്ക് ഏകീകൃത തിരിച്ചറിയലുകൾ സൃഷ്ടിക്കുന്നു, ഇത് വലിയ തോതിലുള്ള ഡാറ്റ പ്രോസസ്സിംഗിന് കൈകാര്യം ചെയ്യാൻ ട്വിറ്റർ വികസിപ്പിച്ചെടുത്തതാണ്. ഈ ശക്തമായ ഏകീകൃത ഐഡി ജനറേറ്റർ ഒരു ടൈംസ്റ്റാമ്പ്, മെഷീൻ ഐഡി, സീക്വൻസ് നമ്പർ എന്നിവയാൽ രൂപീകരിച്ച 64-ബിറ്റ് ഇന്റേജറുകൾ ഉൽപ്പാദിപ്പിക്കുന്നു, ഇത് വിതരണ സംവിധാനങ്ങളിൽ ഏകീകൃതത്വം ഉറപ്പാക്കുന്നു സർവറുകൾക്കിടയിൽ സഹകരണമില്ലാതെ.
ഞങ്ങളുടെ സൗജന്യ ഓൺലൈൻ സ്നോഫ്ലേക്ക് ഐഡി ജനറേറ്റർ ഉപകരണം നിങ്ങൾക്ക് സ്നോഫ്ലേക്ക് ഐഡുകൾ സൃഷ്ടിക്കുകയും പാഴ്സുചെയ്യുകയും ഉടൻ ചെയ്യാൻ അനുവദിക്കുന്നു, ഇത് മൈക്രോസർവീസുകൾ, വിതരണ ഡാറ്റാബേസുകൾ, ഉയർന്ന throughput ആപ്ലിക്കേഷനുകൾ എന്നിവയുമായി പ്രവർത്തിക്കുന്ന ഡെവലപ്പർമാർക്കായി അനുയോജ്യമാണ്.
സ്നോഫ്ലേക്ക് ഐഡുകൾ ഏകീകൃതത്വം ഉറപ്പാക്കുന്ന സൂക്ഷ്മമായി രൂപകൽപ്പന ചെയ്ത ഘടനയുള്ള 64-ബിറ്റ് ഇന്റേജറുകളാണ്:
ഈ വിതരണ ഐഡി ഘടന ഏകദേശം 4,096 ഏകീകൃത ഐഡുകൾ ഓരോ മില്ലിസെക്കൻഡിലും ഓരോ മെഷീനിൽ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു, ഇത് ഉയർന്ന throughput വിതരണ സംവിധാനങ്ങൾക്ക് അനുയോജ്യമാണ്.
ഏകീകൃത സ്നോഫ്ലേക്ക് ഐഡുകൾ സൃഷ്ടിക്കാൻ ഈ ലളിതമായ ഘട്ടങ്ങൾ പിന്തുടരുക:
ഒരു സ്നോഫ്ലേക്ക് ഐഡി ഡികോഡ് ചെയ്യാൻ, "പാഴ്സ് ഐഡി" ഫീൽഡിൽ അത് നൽകുക, ടൈംസ്റ്റാമ്പ്, മെഷീൻ ഐഡി, സീക്വൻസ് ഘടകങ്ങൾ കാണാൻ "പാഴ്സ്" ക്ലിക്ക് ചെയ്യുക.
സ്നോഫ്ലേക്ക് ഐഡി ആൽഗോരിതം ബിറ്റ്‌വൈസ് പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് ഏകീകൃത തിരിച്ചറിയലുകൾ നിർമ്മിക്കുന്നു:
1ID = (timestamp << 22) | (datacenterId << 17) | (workerId << 12) | sequence
2ഫോർമുല ഘടകങ്ങൾ:
timestamp: എപ്പോക്കിൽ നിന്ന് മില്ലിസെക്കൻഡുകളുടെ എണ്ണംdatacenterId: ഡാറ്റാ സെന്റർ തിരിച്ചറിയുന്ന 5-ബിറ്റ് ഇന്റേജർ (0-31)workerId: വർകർ മെഷീൻ തിരിച്ചറിയുന്ന 5-ബിറ്റ് ഇന്റേജർ (0-31)sequence: ഒരു മില്ലിസെക്കൻഡിൽ നിരവധി ഐഡുകൾക്കായി 12-ബിറ്റ് ഇന്റേജർ (0-4095)സ്നോഫ്ലേക്ക് ഐഡി ജനറേഷൻ ആൽഗോരിതം ഈ കൃത്യമായ ഘട്ടങ്ങൾ പിന്തുടരുന്നു:
ഈ പ്രക്രിയ ഓരോ മെഷീനിലും ഏകീകൃതമായി വർദ്ധിക്കുന്ന ഐഡുകൾ ഉറപ്പാക്കുന്നു, അതേസമയം വിതരണ സംവിധാനങ്ങളിൽ ആഗോള ഏകീകൃതത്വം നിലനിര്‍ത്തുന്നു.
സ്നോഫ്ലേക്ക് ഐഡുകൾ വിവിധ വിതരണ കമ്പ്യൂട്ടിംഗ് സാഹചര്യങ്ങളിൽ മികച്ചതാണ്:
സ്നോഫ്ലേക്ക് ഐഡുകൾ ശക്തമായവയായിരിക്കുമ്പോൾ, മറ്റ് ഏകീകൃത ഐഡി ജനറേഷൻ സിസ്റ്റങ്ങൾ ഉൾപ്പെടുന്നു:
സ്നോഫ്ലേക്ക് ഐഡി പരിധികൾ മനസ്സിലാക്കുന്നത് ശരിയായ നടപ്പിലാക്കലിൽ സഹായിക്കുന്നു:
സ്നോഫ്ലേക്ക് ഐഡുകൾ 2010-ൽ ട്വിറ്റർ അവതരിപ്പിച്ചു, വലിയ തോതിൽ വിതരണ, സമയം ക്രമീകരിക്കാവുന്ന ഏകീകൃത തിരിച്ചറിയലുകൾ സൃഷ്ടിക്കുന്ന വെല്ലുവിളി പരിഹരിക്കാൻ. ട്വിറ്ററിന്റെ ഉപയോക്തൃ അടിസ്ഥാനവും ട്വീറ്റ് വോളിയവും പൊട്ടിത്തെറിക്കുമ്പോൾ, പരമ്പരാഗത ഓട്ടോ-ഇൻക്രിമെന്റിംഗ് ഐഡുകൾ അവരുടെ വിതരണ ആർക്കിടെക്ചറിക്ക് മതിയല്ല.
ഈ സംവിധാനം പിന്നീട് ഇൻസ്റ്റാഗ്രാം, ഡിസ്കോർഡ്, മറ്റ് നിരവധി പ്ലാറ്റ്ഫോമുകൾ എന്നിവയുൾപ്പെടെ പ്രധാന ടെക് കമ്പനികൾക്കാൽ സ്വീകരിക്കപ്പെട്ടു, വിതരണ സംവിധാനങ്ങൾക്കായി സ്കെയിലബിള് ഐഡി ജനറേഷൻ ആവശ്യമാണ്.
നിങ്ങളുടെ ഇഷ്ടപ്പെട്ട പ്രോഗ്രാമിംഗ് ഭാഷയിൽ സ്നോഫ്ലേക്ക് ഐഡി ജനറേഷൻ നടപ്പിലാക്കുക:
1class SnowflakeGenerator {
2 constructor(epoch = 1288834974657, datacenterIdBits = 5, workerIdBits = 5, sequenceBits = 12) {
3 this.epoch = BigInt(epoch);
4 this.datacenterIdBits = datacenterIdBits;
5 this.workerIdBits = workerIdBits;
6 this.sequenceBits = sequenceBits;
7 this.maxDatacenterId = -1n ^ (-1n << BigInt(datacenterIdBits));
8 this.maxWorkerId = -1n ^ (-1n << BigInt(workerIdBits));
9 this.sequenceMask = -1n ^ (-1n << BigInt(sequenceBits));
10 this.workerIdShift = BigInt(sequenceBits);
11 this.datacenterIdShift = BigInt(sequenceBits + workerIdBits);
12 this.timestampLeftShift = BigInt(sequenceBits + workerIdBits + datacenterIdBits);
13 this.sequence = 0n;
14 this.lastTimestamp = -1n;
15 }
16
17 nextId(datacenterId, workerId) {
18 let timestamp = this.currentTimestamp();
19
20 if (timestamp < this.lastTimestamp) {
21 throw new Error('Clock moved backwards. Refusing to generate id');
22 }
23
24 if (timestamp === this.lastTimestamp) {
25 this.sequence = (this.sequence + 1n) & this.sequenceMask;
26 if (this.sequence === 0n) {
27 timestamp = this.tilNextMillis(this.lastTimestamp);
28 }
29 } else {
30 this.sequence = 0n;
31 }
32
33 this.lastTimestamp = timestamp;
34
35 return ((timestamp - this.epoch) << this.timestampLeftShift) |
36 (BigInt(datacenterId) << this.datacenterIdShift) |
37 (BigInt(workerId) << this.workerIdShift) |
38 this.sequence;
39 }
40
41 tilNextMillis(lastTimestamp) {
42 let timestamp = this.currentTimestamp();
43 while (timestamp <= lastTimestamp) {
44 timestamp = this.currentTimestamp();
45 }
46 return timestamp;
47 }
48
49 currentTimestamp() {
50 return BigInt(Date.now());
51 }
52}
53
54// Usage
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Generated Snowflake ID: ${id}`);
581import time
2import threading
3
4class SnowflakeGenerator:
5 def __init__(self, datacenter_id, worker_id, sequence=0):
6 self.datacenter_id = datacenter_id
7 self.worker_id = worker_id
8 self.sequence = sequence
9
10 self.last_timestamp = -1
11 self.epoch = 1288834974657
12
13 self.datacenter_id_bits = 5
14 self.worker_id_bits = 5
15 self.sequence_bits = 12
16
17 self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)
18 self.max_worker_id = -1 ^ (-1 << self.worker_id_bits)
19
20 self.worker_id_shift = self.sequence_bits
21 self.datacenter_id_shift = self.sequence_bits + self.worker_id_bits
22 self.timestamp_left_shift = self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
23 self.sequence_mask = -1 ^ (-1 << self.sequence_bits)
24
25 self._lock = threading.Lock()
26
27 def _til_next_millis(self, last_timestamp):
28 timestamp = self._get_timestamp()
29 while timestamp <= last_timestamp:
30 timestamp = self._get_timestamp()
31 return timestamp
32
33 def _get_timestamp(self):
34 return int(time.time() * 1000)
35
36 def next_id(self):
37 with self._lock:
38 timestamp = self._get_timestamp()
39
40 if timestamp < self.last_timestamp:
41 raise ValueError("Clock moved backwards. Refusing to generate id")
42
43 if timestamp == self.last_timestamp:
44 self.sequence = (self.sequence + 1) & self.sequence_mask
45 if self.sequence == 0:
46 timestamp = self._til_next_millis(self.last_timestamp)
47 else:
48 self.sequence = 0
49
50 self.last_timestamp = timestamp
51
52 return ((timestamp - self.epoch) << self.timestamp_left_shift) | \
53 (self.datacenter_id << self.datacenter_id_shift) | \
54 (self.worker_id << self.worker_id_shift) | \
55 self.sequence
56
57## Usage
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Generated Snowflake ID: {snowflake_id}")
61import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class SnowflakeGenerator { private final long epoch; private final long datacenterIdBits; private final long workerIdBits; private final long sequenceBits; private final long maxDatacenterId; private final long maxWorkerId; private final long workerIdShift; private final long datacenterIdShift; private final long timestampLeftShift; private final long sequenceMask; private long datacenterId; private long workerId; private long sequence = 0L; private long lastTimestamp = -1L; private final Lock lock = new ReentrantLock(); public SnowflakeGenerator(long datacenterId, long workerId) { this.epoch = 1288834974657L; this.datacenterIdBits = 5L; this.workerIdBits = 5L; this.sequenceBits = 12L; this.maxDatacenterId = ~(-1L << datacenterIdBits); this.maxWorkerId = ~(-1L << workerIdBits); this.workerIdShift = sequenceBits; this.datacenterIdShift = sequenceBits + workerIdBits; this.timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; this.sequenceMask = ~(-1L << sequenceBits); if (datacenterId > maxDatacenterId || datacenterId < 0) { throw new IllegalArgumentException("datacenterId can't be greater than maxDatacenterId or less than 0"); } if (workerId > maxWorkerId || workerId < 0) { throw new IllegalArgumentException("workerId can't be greater than maxWorkerId or less than 0"); } this.datacenterId = datacenterId; this.workerId = workerId; } public long nextId() { lock.lock(); try { long timestamp = timeGen(); if (timestamp < lastTimestamp) { throw new RuntimeException("Clock moved backwards. Refusing to generate id"); } if (lastTimestamp == timestamp) { sequence = (sequence + 1) & sequenceMask; if (sequence == 0) { timestamp = tilNextMillis(lastTimestamp); } } else { sequence = 0L; } lastTimestamp = timestamp; return ((timestamp - epoch) << timestampLeftShift) | (datacenterId << datacenterIdShift) | (workerId << workerIdShift) | sequence; } finally { lock.unlock(); } } private long tilNextMillis(long
നിങ്ങളുടെ പ്രവർത്തനത്തിന് ഉപയോഗപ്പെടുന്ന കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക.