ट्विटर स्नोफ्लेक आयडी, वितरित प्रणालींमध्ये वापरले जाणारे अद्वितीय 64-बिट ओळखपत्र तयार करा आणि विश्लेषण करा. हे साधन तुम्हाला नवीन स्नोफ्लेक आयडी तयार करण्याची आणि विद्यमान आयडींचे पार्सिंग करण्याची परवानगी देते, त्यांच्या टाइमस्टॅम्प, मशीन आयडी, आणि अनुक्रमांक घटकांमध्ये अंतर्दृष्टी प्रदान करते.
एक स्नोफ्लेक आयडी जनरेटर वितरित प्रणालीसाठी अद्वितीय आयडेंटिफायर्स तयार करतो, जो मूळतः ट्विटरने विशाल प्रमाण डेटा प्रक्रिया हाताळण्यासाठी विकसित केला होता. हा शक्तिशाली अद्वितीय आयडी जनरेटर 64-बिट पूर्णांक तयार करतो जो एक टाइमस्टॅम्प, मशीन आयडी, आणि अनुक्रम क्रमांक यांचा समावेश करतो, यामुळे वितरित प्रणालींमध्ये अद्वितीयता सुनिश्चित होते ज्यासाठी सर्व्हर्समध्ये समन्वयाची आवश्यकता नसते.
आमचा मोफत ऑनलाइन स्नोफ्लेक आयडी जनरेटर साधन तुम्हाला स्नोफ्लेक आयडी तयार आणि पार्स करण्याची परवानगी देतो, ज्यामुळे हे मायक्रोसर्व्हिसेस, वितरित डेटाबेस, आणि उच्च-थ्रूपुट अनुप्रयोगांसाठी काम करणाऱ्या विकासकांसाठी आदर्श आहे.
स्नोफ्लेक आयडी 64-बिट पूर्णांक आहेत ज्यांची रचना काळजीपूर्वक तयार केलेली आहे जी अद्वितीयता सुनिश्चित करते:
हा वितरित आयडी संरचना प्रत्येक मशीनसाठी सुमारे 4,096 अद्वितीय आयडी प्रति मिलीसेकंद तयार करण्यास सक्षम करते, ज्यामुळे हे उच्च-थ्रूपुट वितरित प्रणालींसाठी आदर्श आहे.
अद्वितीय स्नोफ्लेक आयडी तयार करण्यासाठी या सोप्या चरणांचे पालन करा:
स्नोफ्लेक आयडी डिकोड करण्यासाठी, "पार्स आयडी" फील्डमध्ये तो प्रविष्ट करा आणि टाइमस्टॅम्प, मशीन आयडी, आणि अनुक्रम घटक पहाण्यासाठी "पार्स" वर क्लिक करा.
स्नोफ्लेक आयडी अल्गोरिदम बिटवाइज ऑपरेशन्सचा वापर करून अद्वितीय आयडेंटिफायर्स तयार करतो:
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('घड्याळ मागे सरकले. आयडी तयार करण्यास नकार');
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// वापर
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`तयार केलेला स्नोफ्लेक आयडी: ${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("घड्याळ मागे सरकले. आयडी तयार करण्यास नकार")
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## वापर
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"तयार केलेला स्नोफ्लेक आयडी: {snowflake_id}")
611import java.util.concurrent.locks.Lock;
2import java.util.concurrent.locks.ReentrantLock;
3
4public class SnowflakeGenerator {
5 private final long epoch;
6 private final long datacenterIdBits;
7 private final long workerIdBits;
8 private final long sequenceBits;
9 private final long maxDatacenterId;
10 private final long maxWorkerId;
11 private final long workerIdShift;
12 private final long datacenterIdShift;
13 private final long timestampLeftShift;
14 private final long sequenceMask;
15
16 private long datacenterId;
17 private long workerId;
18 private long sequence = 0L;
19 private long lastTimestamp = -1L;
20
21 private final Lock lock = new ReentrantLock();
22
23 public SnowflakeGenerator(long datacenterId, long workerId) {
24 this.epoch = 1288834974657L;
25 this.datacenterIdBits = 5L;
26 this.workerIdBits = 5L;
27 this.sequenceBits = 12L;
28
29 this.maxDatacenterId = ~(-1L << datacenterIdBits);
30 this.maxWorkerId = ~(-1L << workerIdBits);
31
32 this.workerIdShift = sequenceBits;
33 this.datacenterIdShift = sequenceBits + workerIdBits;
34 this.timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
35 this.sequenceMask = ~(-1L << sequenceBits);
36
37 if (datacenterId > maxDatacenterId || datacenterId < 0) {
38 throw new IllegalArgumentException("datacenterId can't be greater than maxDatacenterId or less than 0");
39 }
40 if (workerId > maxWorkerId || workerId < 0) {
41 throw new IllegalArgumentException("workerId can't be greater than maxWorkerId or less than 0");
42 }
43 this.datacenterId = datacenterId;
44 this.workerId = workerId;
45 }
46
47 public long nextId() {
48 lock.lock();
49 try {
50 long timestamp = timeGen();
51 if (timestamp < lastTimestamp) {
52 throw new RuntimeException("घड्याळ मागे सरकले. आयडी तयार करण्यास नकार");
53 }
54
55 if (lastTimestamp == timestamp) {
56 sequence = (sequence + 1) & sequenceMask;
57 if (sequence == 0) {
58 timestamp = tilNextMillis(lastTimestamp);
59 }
60 } else {
61 sequence = 0L;
62 }
63
64 lastTimestamp = timestamp;
65
66 return ((timestamp - epoch) << timestampLeftShift) |
67 (datacenterId << datacenterIdShift) |
68 (workerId << workerIdShift) |
69 sequence;
70 } finally {
71 lock.unlock();
72 }
73 }
74
75 private long tilNextMillis(long lastTimestamp) {
76 long timestamp = timeGen();
77 while (timestamp <= lastTimestamp) {
78 timestamp = timeGen();
79 }
80 return timestamp;
81 }
82
83 private long timeGen() {
84 return System.currentTimeMillis();
85 }
86
87 public static void main(String[] args) {
88 SnowflakeGenerator generator = new SnowflakeGenerator(1, 1);
89 long id = generator.nextId();
90 System.out.println("तयार केलेला स्नोफ्लेक आयडी: " + id);
91 }
92}
93require 'time' class SnowflakeGenerator def initialize(datacenter_id, worker_id, sequence = 0) @datacenter_id = datacenter_id @worker_id = worker_id @sequence = sequence @last_timestamp = -1 @epoch = 1288834974657 @datacenter_id_bits = 5 @worker_id_bits = 5 @sequence_bits = 12 @max_datacenter_id = -1 ^ (-1 << @datacenter_id_bits) @max_worker_id = -1 ^ (-1 << @worker_id_bits) @worker_id_shift = @sequence_bits @datacenter_id_shift = @sequence_bits + @worker_id_bits @timestamp_left_shift = @sequence_bits + @worker_id_bits + @datacenter_id_bits @sequence_mask = -1 ^ (-1 << @sequence_bits) end def next_id timestamp = (Time.now.to_f * 1000).to_i raise 'घड्याळ मागे सरकले' if timestamp
आपल्या कामच्या प्रक्रियेसाठी उपयुक्त असणारे अधिक उपकरण शोधा.