Generátor ID Snowflake: Vytvorte jedinečné identifikátory distribuovaných systémov

Čo je generátor ID Snowflake?

Generátor ID Snowflake vytvára jedinečné identifikátory pre distribuované systémy, pôvodne vyvinutý spoločnosťou Twitter na spracovanie masívneho množstva dát. Tento výkonný generátor jedinečných ID produkuje 64-bitové celé čísla zložené z časovej pečiatky, ID stroja a sekvenčného čísla, čím zabezpečuje jedinečnosť v rámci distribuovaných systémov bez koordinácie medzi servermi.

Náš bezplatný online nástroj na generovanie ID Snowflake vám umožňuje okamžite generovať a analyzovať ID Snowflake, čo je ideálne pre vývojárov pracujúcich s mikroservisami, distribuovanými databázami a aplikáciami s vysokým prenosom.

Ako funguje generovanie ID Snowflake

ID Snowflake sú 64-bitové celé čísla s starostlivo navrhnutou štruktúrou, ktorá zaručuje jedinečnosť:

41 bitov: Časová pečiatka (milisekundy od vlastnej epochy)
10 bitov: ID stroja (5 bitov pre ID dátového centra, 5 bitov pre ID pracovníka)
12 bitov: Sekvenčné číslo

Táto distribuovaná štruktúra ID umožňuje generovanie približne 4 096 jedinečných ID za milisekundu na stroj, čo je ideálne pre systémy s vysokým prenosom.

Ako používať náš nástroj na generovanie ID Snowflake

Postupujte podľa týchto jednoduchých krokov na generovanie jedinečných ID Snowflake:

Nastavte vlastnú epochu (voliteľné): Použite predvolenú epochu Twitteru (2010-11-04T01:42:54.657Z) alebo nastavte svoju vlastnú
Konfigurujte ID strojov: Zadajte ID stroja (0-31) a ID dátového centra (0-31)
Generujte ID: Kliknite na "Generovať" a vytvorte nové jedinečné ID Snowflake
Zobraziť výsledky: Pozrite si vygenerované ID a jeho rozloženie komponentov

Analyzujte existujúce ID Snowflake

Na dekódovanie ID Snowflake ho zadajte do poľa "Analyzovať ID" a kliknite na "Analyzovať", aby ste videli jeho časovú pečiatku, ID stroja a sekvenčné komponenty.

Formula generovania ID Snowflake

Algoritmus ID Snowflake konštruuje jedinečné identifikátory pomocou bitových operácií:

1ID = (časová pečiatka << 22) | (ID dátového centra << 17) | (ID pracovníka << 12) | sekvencia
2

Komponenty vzorca:

časová pečiatka: Počet milisekúnd od epochy
ID dátového centra: 5-bitové celé číslo (0-31) identifikujúce dátové centrum
ID pracovníka: 5-bitové celé číslo (0-31) identifikujúce pracovný stroj
sekvencia: 12-bitové celé číslo (0-4095) pre viacero ID za milisekundu

Proces výpočtu ID Snowflake

Algoritmus generovania ID Snowflake dodržiava tieto presné kroky:

Získajte aktuálnu časovú pečiatku: Získajte aktuálny čas v milisekundách
Zabezpečte chronologický poriadok: Overte, či časová pečiatka presahuje poslednú použitú časovú pečiatku
Riešte rovnakú časovú pečiatku: Ak sa časová pečiatka zhoduje s predchádzajúcou, zvýšte sekvenčné číslo
Zabráňte pretečeniu: Ak sekvencia dosiahne 4096, počkajte na ďalšiu milisekundu
Kombinujte komponenty: Použite bitové operácie na vytvorenie konečného jedinečného ID

Tento proces zaručuje monotonicky rastúce ID v rámci každého stroja, pričom zachováva globálnu jedinečnosť v rámci distribuovaných systémov.

Použitie ID Snowflake a aplikácie

ID Snowflake excelujú v rôznych scenároch distribuovaného výpočtu:

Hlavné prípady použitia

Distribuované systémy: Generujte jedinečné ID naprieč viacerými strojmi bez koordinácie
Spracovanie dát s vysokým objemom: Vytvárajte triediteľné ID pre masívne dátové sady
Architektúra mikroservisov: Zabezpečte jedinečné identifikátory naprieč rôznymi službami
Shardovanie databáz: Použite komponenty časovej pečiatky alebo ID stroja na efektívne rozdelenie dát

Aplikácie v reálnom svete

Sociálne médiá: Twitter, Instagram pre ID príspevkov a používateľov
E-commerce systémy: Sledovanie objednávok a správa zásob
Zber dát IoT: Zaznamenávanie udalostí zariadení a dát zo senzorov
Finančné systémy: Spracovanie transakcií a auditné stopy

Alternatívy a porovnania ID Snowflake

Aj keď sú ID Snowflake mocné, iné systémy generovania jedinečných ID zahŕňajú:

Alternatívne systémy ID

UUID (Univerzálne jedinečné identifikátory): Najlepšie pre distribuovanú generáciu bez požiadaviek na triediteľnosť
Automaticky zvyšujúce sa ID databázy: Jednoduché riešenie obmedzené na jednotlivé databázové instance
ULID (Univerzálne jedinečné lexikograficky triediteľné identifikátory): Podobné ako Snowflake s kódovaním base32
NanoID: Kompaktný, URL-bezpečný generátor jedinečných reťazcov pre webové aplikácie

Obmedzenia a úvahy o ID Snowflake

Pochopenie obmedzení ID Snowflake pomáha pri správnej implementácii:

Bežné výzvy

Problémy so synchronizáciou hodín: Závislosti na systémovom čase môžu spôsobiť problémy s úpravami NTP alebo zmenami letného času
Obmedzenie roku 2079: Pretečenie 41-bitovej časovej pečiatky si vyžaduje dlhodobé plánovanie pre systémy s vysokou škálou
Správa ID strojov: Zabezpečenie jedinečných ID strojov naprieč veľkými distribuovanými systémami si vyžaduje koordináciu
Pretečenie sekvencie: Extrémne scenáre s vysokým prenosom môžu vyčerpať 4096 sekvencií za milisekundu
Poradie naprieč strojmi: ID sú monotónne na každom stroji, ale nie globálne naprieč všetkými strojmi

História ID Snowflake

ID Snowflake boli predstavené spoločnosťou Twitter v roku 2010 na riešenie výzvy generovania distribuovaných, časovo triediteľných jedinečných identifikátorov v masívnom meradle. Keď sa používateľská základňa Twitteru a objem tweetov explodovali, tradičné automaticky zvyšujúce sa ID sa stali nedostatočnými pre ich distribuovanú architektúru.

Systém bol odvtedy prijatý veľkými technologickými spoločnosťami vrátane Instagramu, Discordu a nespočetných ďalších platforiem, ktoré vyžadujú škálovateľnú generáciu ID pre distribuované systémy.

Príklady kódu generátora ID Snowflake

Implementujte generovanie ID Snowflake vo svojom preferovanom programovacom jazyku:

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('Hodiny sa posunuli späť. Odmietam generovať 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// Použitie
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Vygenerované ID Snowflake: ${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("Hodiny sa posunuli späť. Odmietam generovať 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## Použitie
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Vygenerované ID Snowflake: {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 nemôže byť väčší ako maxDatacenterId alebo menší ako 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId nemôže byť väčší ako maxWorkerId alebo menší ako 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("Hodiny sa posunuli späť. Odmietam generovať 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("Vygenerované ID Snowflake: " + 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 'Hodiny sa posunuli späť' if timestamp < @last_timestamp

    if timestamp == @last_timestamp
      @sequence = (@sequence + 1) & @sequence_mask
      timestamp = til_next_millis(@last_timestamp) if @sequence == 0
    else
      @sequence = 0
    end

    @last_timestamp = timestamp

    ((timestamp - @epoch) << @timestamp_left_shift) |
      (@datacenter_id << @datacenter_id_shift) |
      (@worker_id << @worker_id_shift) |
      @sequence
  end

  private

  def til_next_millis(last_timestamp)
    timestamp = (Time.now.to_f

Whiz Tools

Nástroj na generovanie a analýzu Twitter Snowflake ID pre poznatky

Generátor Snowflake ID

Generátor Snowflake ID

Dokumentácia

Generátor ID Snowflake: Vytvorte jedinečné identifikátory distribuovaných systémov

Čo je generátor ID Snowflake?

Ako funguje generovanie ID Snowflake

Ako používať náš nástroj na generovanie ID Snowflake

Analyzujte existujúce ID Snowflake

Formula generovania ID Snowflake

Proces výpočtu ID Snowflake

Použitie ID Snowflake a aplikácie

Hlavné prípady použitia

Aplikácie v reálnom svete

Alternatívy a porovnania ID Snowflake

Alternatívne systémy ID

Obmedzenia a úvahy o ID Snowflake

Bežné výzvy

História ID Snowflake

Príklady kódu generátora ID Snowflake

Súvisiace nástroje

Generátor UUID pre rôzne aplikácie a systémy

Nano ID Generátor - Vytvorte bezpečné URL-priateľské jedinečné ID

Generátor názvov náhodných projektov

Generátor náhodných používateľských agentov pre testovanie webového vývoja

Generátor náhodných API kľúčov: Vytvorte zabezpečené 32-znakové reťazce

Generátor CPF na testovanie a validáciu údajov

Generátor náhodných lokalít: Tvorca globálnych súradníc

Generátor MD5 Hash

Efektívny generátor KSUID pre jedinečné identifikátory v systémoch

Generátor mien pre deti s kategóriami - Nájdite dokonalé meno