Izveidojiet un analizējiet Twitter Snowflake ID, unikālus 64 bitu identifikatorus, kas tiek izmantoti izplatītās sistēmās. Šis rīks ļauj jums izveidot jaunus Snowflake ID un analizēt esošos, sniedzot ieskatus to laika zīmē, mašīnas ID un secības numura komponentēs.
Sniega Pārslas ID ģenerators izveido unikālus identifikatorus izplatītām sistēmām, sākotnēji izstrādāts Twitter, lai apstrādātu milzīgu datu apjomu. Šis jaudīgais unikālo ID ģenerators ražo 64 bitu veselus skaitļus, kas sastāv no laika zīmoga, mašīnas ID un secības numura, nodrošinot unikalitāti izplatītajās sistēmās bez koordinācijas starp serveriem.
Mūsu bezmaksas tiešsaistes Sniega Pārslas ID ģeneratora rīks ļauj jums ģenerēt un analizēt Sniega Pārslas ID nekavējoties, padarot to ideāli piemērotu izstrādātājiem, kas strādā ar mikroservisiem, izplatītām datubāzēm un augstas caurlaidības lietojumprogrammām.
Sniega Pārslas ID ir 64 bitu veseli skaitļi ar rūpīgi izstrādātu struktūru, kas garantē unikalitāti:
Šī izplatītā ID struktūra ļauj ģenerēt aptuveni 4,096 unikālus ID katru milisekundi katrai mašīnai, padarot to ideāli piemērotu augstas caurlaidības izplatītām sistēmām.
Izpildiet šos vienkāršos soļus, lai ģenerētu unikālus Sniega Pārslas ID:
Lai dekodētu Sniega Pārslas ID, ievadiet to laukā "Analizēt ID" un noklikšķiniet uz "Analizēt", lai redzētu tā laika zīmogu, mašīnas ID un secības komponentus.
Sniega Pārslas ID algoritms konstruē unikālus identifikatorus, izmantojot bitu operācijas:
1ID = (laika_zīmogs << 22) | (datu_centraId << 17) | (darbaId << 12) | secība
2Formulas komponenti:
laika_zīmogs: Milisekunžu skaits kopš laikmetadatu_centraId: 5 bitu vesels skaitlis (0-31), kas identificē datu centrudarbaId: 5 bitu vesels skaitlis (0-31), kas identificē darba mašīnusecība: 12 bitu vesels skaitlis (0-4095) vairākiem ID katru milisekundiSniega Pārslas ID ģenerēšanas algoritms seko šiem precīzajiem soļiem:
Šis process garantē monotoniski pieaugošus ID katrā mašīnā, vienlaikus saglabājot globālo unikalitāti izplatītajās sistēmās.
Sniega Pārslas ID izceļas dažādās izplatītās skaitļošanas situācijās:
Lai gan Sniega Pārslas ID ir jaudīgi, citas unikālo ID ģenerēšanas sistēmas ietver:
Izpratne par Sniega Pārslas ID ierobežojumiem palīdz pareizai ieviešanai:
Sniega Pārslas ID tika ieviesti Twitter 2010. gadā, lai atrisinātu izaicinājumu ģenerēt izplatītus, laika kārtojamos unikālos identifikatorus milzīgā mērogā. Kad Twitter lietotāju skaits un tvītu apjoms pieauga, tradicionālie automātiski pieaugošie ID kļuva nepietiekami viņu izplatītajai arhitektūrai.
Sistēma kopš tā laika ir pieņemta lielos tehnoloģiju uzņēmumos, tostarp Instagram, Discord un neskaitāmās citās platformās, kas prasa mērogojamu ID ģenerēšanu izplatītajām sistēmām.
Ieviesiet Sniega Pārslas ID ģenerēšanu savā izvēlētajā programmēšanas valodā:
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('Pulkstenis pārvietojies atpakaļ. Atsakāmies ģenerēt 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// Lietošana
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Ģenerētais Sniega Pārslas 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("Pulkstenis pārvietojies atpakaļ. Atsakāmies ģenerēt 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## Lietošana
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Ģenerētais Sniega Pārslas ID: {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("datu_centraId nedrīkst būt lielāks par maxDatacenterId vai mazāks par 0");
39 }
40 if (workerId > maxWorkerId || workerId < 0) {
41 throw new IllegalArgumentException("darbaId nedrīkst būt lielāks par maxWorkerId vai mazāks par 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("Pulkstenis pārvietojies atpakaļ. Atsakāmies ģenerēt id");
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("Ģenerētais Sniega Pārslas ID: " + 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 =
Atklājiet vairāk rīku, kas varētu būt noderīgi jūsu darbplūsmai