Snaigės ID generatorius: kurkite unikalius paskirstytų sistemų identifikatorius

Kas yra Snaigės ID generatorius?

Snaigės ID generatorius kuria unikalius identifikatorius paskirstytoms sistemoms, pirmiausia sukurtas „Twitter“ dideliems duomenų apdorojimo mastams valdyti. Šis galingas unikalus ID generatorius gamina 64 bitų sveikųjų skaičių, sudarytų iš laiko žymės, mašinos ID ir sekos numerio, užtikrinant unikalumą paskirstytose sistemose be serverių koordinavimo.

Mūsų nemokamas internetinis Snaigės ID generatoriaus įrankis leidžia jums generuoti ir analizuoti Snaigės ID akimirksniu, todėl jis puikiai tinka kūrėjams, dirbantiems su mikroservisais, paskirstytomis duomenų bazėmis ir didelio pralaidumo programomis.

Kaip veikia Snaigės ID generavimas

Snaigės ID yra 64 bitų sveikieji skaičiai su kruopščiai sukurta struktūra, garantuojančia unikalumą:

41 bitas: Laiko žymė (milisekundės nuo pasirinkto epochos)
10 bitų: Mašinos ID (5 bitai duomenų centro ID, 5 bitai darbuotojo ID)
12 bitų: Sekos numeris

Ši paskirstyta ID struktūra leidžia generuoti maždaug 4,096 unikalius ID per milisekundę kiekvienai mašinai, todėl ji idealiai tinka didelio pralaidumo paskirstytoms sistemoms.

Kaip naudoti mūsų Snaigės ID generatoriaus įrankį

Sekite šiuos paprastus žingsnius, kad sukurtumėte unikalius Snaigės ID:

Nustatyti pasirinktinę epochą (Pasirinktinai): Naudokite numatytąją „Twitter“ epochą (2010-11-04T01:42:54.657Z) arba nustatykite savo
Konfigūruoti mašinos ID: Įveskite mašinos ID (0-31) ir duomenų centro ID (0-31)
Generuoti ID: Paspauskite „Generuoti“, kad sukurtumėte naują unikalų Snaigės ID
Peržiūrėti rezultatus: Peržiūrėkite sugeneruotą ID ir jo komponentų išskaidymą

Analizuoti esamus Snaigės ID

Norėdami iššifruoti Snaigės ID, įveskite jį į „Analizuoti ID“ laukelį ir paspauskite „Analizuoti“, kad pamatytumėte jo laiko žymę, mašinos ID ir sekos komponentus.

Snaigės ID generavimo formulė

Snaigės ID algoritmas konstruoja unikalius identifikatorius naudodamas bitų operacijas:

1ID = (laiko žymė << 22) | (duomenų centro ID << 17) | (darbuotojo ID << 12) | seka
2

Formulės komponentai:

laiko žymė: Milisekundžių skaičius nuo epochos
duomenų centro ID: 5 bitų sveikasis skaičius (0-31), identifikuojantis duomenų centrą
darbuotojo ID: 5 bitų sveikasis skaičius (0-31), identifikuojantis darbuotojo mašiną
seka: 12 bitų sveikasis skaičius (0-4095) keliems ID per milisekundę

Snaigės ID skaičiavimo procesas

Snaigės ID generavimo algoritmas vykdo šiuos tiksliai apibrėžtus žingsnius:

Gauti dabartinę laiko žymę: Gauti dabartinį laiką milisekundėmis
Užtikrinti chronologinę tvarką: Patikrinti, ar laiko žymė viršija paskutinę naudotą laiko žymę
Tvarkyti tą pačią laiko žymę: Jei laiko žymė atitinka ankstesnę, padidinti sekos numerį
Išvengti perpildymo: Jei seka pasiekia 4096, palaukti kitos milisekundės
Sujungti komponentus: Naudoti bitų operacijas, kad sukurtumėte galutinį unikalų ID

Šis procesas garantuoja monotoniškai didėjančius ID kiekvienoje mašinoje, tuo pačiu užtikrinant globalų unikalumą paskirstytose sistemose.

Snaigės ID naudojimo atvejai ir taikymai

Snaigės ID puikiai tinka įvairiems paskirstyto skaičiavimo scenarijams:

Pagrindiniai naudojimo atvejai

Paskirstytos sistemos: Generuoti unikalius ID kelioms mašinoms be koordinavimo
Didelio tūrio duomenų apdorojimas: Kurti rūšiuojamus ID dideliems duomenų rinkiniams
Mikroservisų architektūra: Užtikrinti unikalius identifikatorius skirtingoms paslaugoms
Duomenų bazės dalijimas: Naudoti laiko žymės arba mašinos ID komponentus efektyviam duomenų skirstymui

Realių pasaulio taikymų pavyzdžiai

Socialinės žiniasklaidos platformos: „Twitter“, „Instagram“ postų ir vartotojų ID
E-komercijos sistemos: Užsakymų sekimas ir inventoriaus valdymas
IoT duomenų rinkimas: Įrenginių įvykių registravimas ir jutiklių duomenys
Finansų sistemos: Sandorių apdorojimas ir audito takai

Snaigės ID alternatyvos ir palyginimai

Nors Snaigės ID yra galingi, kitos unikalaus ID generavimo sistemos apima:

Alternatyvūs ID sistemų variantai

UUID (Universalus unikalus identifikatorius): Geriausiai tinka paskirstytam generavimui be rūšiavimo reikalavimų
Automatiškai didėjantys duomenų bazės ID: Paprastas sprendimas, ribotas iki vienos duomenų bazės instancijos
ULID (Universalus unikalus leksikografiškai rūšiuojamas identifikatorius): Panašus į Snaigės ID su base32 kodavimu
NanoID: Kompaktiškas, URL saugus unikalus simbolių generatorius interneto programoms

Snaigės ID apribojimai ir svarstymai

Supratimas apie Snaigės ID apribojimus padeda tinkamai įgyvendinti:

Dažniausiai pasitaikančios problemos

Laikrodžio sinchronizavimo problemos: Sistemos laiko priklausomybės gali sukelti problemų su NTP koregavimais ar vasaros laiko pokyčiais
2079 metų apribojimas: 41 bitų laiko žymės perpildymas reikalauja ilgalaikio planavimo didelio masto sistemoms
Mašinos ID valdymas: Užtikrinti unikalius mašinos ID didelėse paskirstytose sistemose reikalauja koordinavimo
Sekos perpildymas: Ypač didelio pralaidumo scenarijai gali išnaudoti 4096 sekas per milisekundę
Kryžminis mašinų užsakymas: ID yra monotoniški kiekvienai mašinai, tačiau ne globaliai visoms mašinoms

Snaigės ID istorija

Snaigės ID buvo pristatyti Twitter 2010 metais, siekiant išspręsti iššūkį generuoti paskirstytus, laiko rūšiuojamus unikalius identifikatorius dideliu mastu. Kai „Twitter“ vartotojų skaičius ir tweetų apimtis išaugo, tradiciniai automatiškai didėjantys ID tapo nepakankami jų paskirstytai architektūrai.

Sistema nuo to laiko buvo priimta didžiųjų technologijų kompanijų, įskaitant „Instagram“, „Discord“ ir daugelį kitų platformų, reikalaujančių skalabilaus ID generavimo paskirstytoms sistemoms.

Snaigės ID generatoriaus kodo pavyzdžiai

Įgyvendinkite Snaigės ID generavimą savo pasirinktoje programavimo kalboje:

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// Naudojimas
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Sugeneruotas Snaigės ID: ${id}`);
58

1import 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## Naudojimas
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Sugeneruotas Snaigės ID: {snowflake_id}")
61

1import 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("Clock moved backwards. Refusing to generate 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("Sugeneruotas Snaigės ID: " + id);
91    }
92}
93

require '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 'Clock moved backwards' if timestamp < @last

Whiz Tools

Generuoti ir analizuoti Twitter Snowflake ID įrankį įžvalgoms

Snaigės ID generatorius