Generator ID Snowflake: Tworzenie unikalnych identyfikatorów systemów rozproszonych

Czym jest generator ID Snowflake?

Generator ID Snowflake tworzy unikalne identyfikatory dla systemów rozproszonych, pierwotnie opracowany przez Twittera do obsługi przetwarzania danych na ogromną skalę. Ten potężny generator unikalnych ID produkuje 64-bitowe liczby całkowite składające się z znacznika czasu, identyfikatora maszyny i numeru sekwencyjnego, zapewniając unikalność w systemach rozproszonych bez koordynacji między serwerami.

Nasz darmowy internetowy narzędzie do generowania ID Snowflake pozwala na generowanie i analizowanie ID Snowflake natychmiast, co czyni je idealnym dla programistów pracujących z mikroserwisami, rozproszonymi bazami danych i aplikacjami o wysokiej przepustowości.

Jak działa generowanie ID Snowflake

ID Snowflake to 64-bitowe liczby całkowite o starannie zaprojektowanej strukturze, która gwarantuje unikalność:

41 bitów: Znacznik czasu (milisekundy od niestandardowej epoki)
10 bitów: Identyfikator maszyny (5 bitów dla identyfikatora centrum danych, 5 bitów dla identyfikatora roboczego)
12 bitów: Numer sekwencyjny

Ta struktura ID rozproszonego umożliwia generowanie około 4,096 unikalnych ID na milisekundę na maszynę, co czyni ją idealną dla systemów rozproszonych o wysokiej przepustowości.

Jak korzystać z naszego narzędzia do generowania ID Snowflake

Postępuj zgodnie z tymi prostymi krokami, aby wygenerować unikalne ID Snowflake:

Ustaw niestandardową epokę (opcjonalnie): Użyj domyślnej epoki Twittera (2010-11-04T01:42:54.657Z) lub ustaw własną
Skonfiguruj identyfikatory maszyn: Wprowadź identyfikator maszyny (0-31) i identyfikator centrum danych (0-31)
Generuj ID: Kliknij "Generuj", aby utworzyć nowe unikalne ID Snowflake
Zobacz wyniki: Zobacz wygenerowane ID i jego składniki

Analizuj istniejące ID Snowflake

Aby dekodować ID Snowflake, wprowadź je w polu "Analizuj ID" i kliknij "Analizuj", aby zobaczyć jego znacznik czasu, identyfikator maszyny i składniki sekwencji.

Wzór generowania ID Snowflake

Algorytm ID Snowflake konstruuje unikalne identyfikatory za pomocą operacji bitowych:

1ID = (znacznik_czasu << 22) | (identyfikatorCentrumDanych << 17) | (identyfikatorRoboczy << 12) | sekwencja
2

Składniki wzoru:

znacznik_czasu: Liczba milisekund od epoki
identyfikatorCentrumDanych: 5-bitowa liczba całkowita (0-31) identyfikująca centrum danych
identyfikatorRoboczy: 5-bitowa liczba całkowita (0-31) identyfikująca maszynę roboczą
sekwencja: 12-bitowa liczba całkowita (0-4095) dla wielu ID na milisekundę

Proces obliczania ID Snowflake

Algorytm generowania ID Snowflake wykonuje te precyzyjne kroki:

Pobierz aktualny znacznik czasu: Uzyskaj aktualny czas w milisekundach
Zapewnij porządek chronologiczny: Sprawdź, czy znacznik czasu przekracza ostatnio używany znacznik czasu
Obsłuż ten sam znacznik czasu: Jeśli znacznik czasu jest taki sam jak poprzedni, zwiększ numer sekwencyjny
Zapobiegaj przepełnieniu: Jeśli sekwencja osiągnie 4096, poczekaj na następną milisekundę
Połącz składniki: Użyj operacji bitowych, aby stworzyć ostateczne unikalne ID

Ten proces gwarantuje monotonicznie rosnące ID w każdej maszynie, jednocześnie zachowując globalną unikalność w systemach rozproszonych.

Przykłady zastosowania i aplikacje ID Snowflake

ID Snowflake doskonale sprawdzają się w różnych scenariuszach obliczeń rozproszonych:

Główne przypadki użycia

Systemy rozproszone: Generuj unikalne ID w wielu maszynach bez koordynacji
Przetwarzanie danych o dużej objętości: Twórz sortowalne ID dla ogromnych zbiorów danych
Architektura mikroserwisów: Zapewnij unikalne identyfikatory w różnych usługach
Shardowanie bazy danych: Użyj składników znacznika czasu lub identyfikatora maszyny do efektywnego partycjonowania danych

Aplikacje w rzeczywistym świecie

Platformy mediów społecznościowych: Twitter, Instagram do identyfikatorów postów i użytkowników
Systemy e-commerce: Śledzenie zamówień i zarządzanie zapasami
Zbieranie danych IoT: Rejestrowanie zdarzeń urządzeń i danych z czujników
Systemy finansowe: Przetwarzanie transakcji i ścieżki audytu

Alternatywy i porównania ID Snowflake

Chociaż ID Snowflake są potężne, inne systemy generacji unikalnych ID obejmują:

Alternatywne systemy ID

UUID (Uniwersalny Unikalny Identyfikator): Najlepszy do rozproszonej generacji bez wymagań dotyczących sortowalności
ID bazy danych z autoinkrementacją: Proste rozwiązanie ograniczone do pojedynczych instancji baz danych
ULID (Uniwersalny Unikalny Identyfikator Sortowalny Leksykograficznie): Podobny do Snowflake z kodowaniem base32
NanoID: Kompaktowy, bezpieczny dla URL generator unikalnych ciągów dla aplikacji internetowych

Ograniczenia i rozważania dotyczące ID Snowflake

Zrozumienie ograniczeń ID Snowflake pomaga w prawidłowej implementacji:

Typowe wyzwania

Problemy z synchronizacją zegara: Zależności od czasu systemowego mogą powodować problemy z dostosowaniami NTP lub zmianami czasu letniego
Ograniczenie roku 2079: Przepełnienie 41-bitowego znacznika czasu wymaga długoterminowego planowania dla systemów o dużej skali
Zarządzanie identyfikatorami maszyn: Zapewnienie unikalnych identyfikatorów maszyn w dużych systemach rozproszonych wymaga koordynacji
Przepełnienie sekwencji: Ekstremalnie wysokie scenariusze przepustowości mogą wyczerpać 4096 sekwencji na milisekundę
Porządek między maszynami: ID są monotoniczne w każdej maszynie, ale nie globalnie we wszystkich maszynach

Historia ID Snowflake

ID Snowflake zostały wprowadzone przez Twittera w 2010 roku, aby rozwiązać problem generowania rozproszonych, sortowalnych czasowo unikalnych identyfikatorów na ogromną skalę. Wraz z eksplozją bazy użytkowników Twittera i objętości tweetów, tradycyjne ID z autoinkrementacją stały się niewystarczające dla ich architektury rozproszonej.

System ten został od tego czasu przyjęty przez główne firmy technologiczne, w tym Instagram, Discord i niezliczone inne platformy wymagające skalowalnej generacji ID dla systemów rozproszonych.

Przykłady kodu generatora ID Snowflake

Zaimplementuj generację ID Snowflake w swoim ulubionym języku programowania:

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('Zegar przesunięty do tyłu. Odrzucam generację 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// Użycie
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Wygenerowane 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("Zegar przesunięty do tyłu. Odrzucam generację 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## Użycie
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Wygenerowane 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("identyfikatorCentrumDanych nie może być większy niż maxDatacenterId lub mniejszy niż 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("identyfikatorRoboczy nie może być większy niż maxWorkerId lub mniejszy niż 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("Zegar przesunięty do tyłu. Odrzucam generację 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("Wygenerowane 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 'Zegar przesunięty do tyłu' 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)

Whiz Tools

Generuj i analizuj narzędzie ID Snowflake Twittera dla wglądów

Generator ID Snowflake