Snowflake ID Generator: Maak Unieke Gedistribueerde Systeem Identifiers

Wat is een Snowflake ID Generator?

Een Snowflake ID generator creëert unieke identifiers voor gedistribueerde systemen, oorspronkelijk ontwikkeld door Twitter voor het verwerken van enorme hoeveelheden data. Deze krachtige unieke ID generator produceert 64-bits gehele getallen die zijn samengesteld uit een tijdstempel, machine-ID en volgnummer, wat uniekheid over gedistribueerde systemen garandeert zonder coördinatie tussen servers.

Onze gratis online Snowflake ID generator tool stelt je in staat om Snowflake IDs te genereren en te parseren in een handomdraai, waardoor het perfect is voor ontwikkelaars die werken met microservices, gedistribueerde databases en applicaties met een hoge doorvoer.

Hoe Snowflake ID Generatie Werkt

Snowflake IDs zijn 64-bits gehele getallen met een zorgvuldig ontworpen structuur die uniekheid garandeert:

41 bits: Tijdstempel (milliseconden sinds een aangepaste epoch)
10 bits: Machine ID (5 bits voor datacenter ID, 5 bits voor worker ID)
12 bits: Volgnummer

Deze gedistribueerde ID-structuur maakt de generatie van ongeveer 4.096 unieke IDs per milliseconde per machine mogelijk, wat het ideaal maakt voor gedistribueerde systemen met een hoge doorvoer.

Hoe Onze Snowflake ID Generator Tool Te Gebruiken

Volg deze eenvoudige stappen om unieke Snowflake IDs te genereren:

Stel Aangepaste Epoch In (Optioneel): Gebruik de standaard Twitter epoch (2010-11-04T01:42:54.657Z) of stel je eigen in
Configureer Machine IDs: Voer machine ID (0-31) en datacenter ID (0-31) in
Genereer ID: Klik op "Genereer" om een nieuwe unieke Snowflake ID te maken
Bekijk Resultaten: Zie de gegenereerde ID en de componenten ervan

Bestaande Snowflake IDs Parseren

Om een Snowflake ID te decoderen, voer deze in het veld "Parse ID" in en klik op "Parse" om de tijdstempel, machine-ID en volgcomponenten te zien.

Snowflake ID Generatie Formule

Het Snowflake ID algoritme construeert unieke identifiers met behulp van bitwise operaties:

1ID = (timestamp << 22) | (datacenterId << 17) | (workerId << 12) | sequence
2

Formule Componenten:

timestamp: Aantal milliseconden sinds de epoch
datacenterId: 5-bits geheel getal (0-31) dat het datacenter identificeert
workerId: 5-bits geheel getal (0-31) dat de worker machine identificeert
sequence: 12-bits geheel getal (0-4095) voor meerdere IDs per milliseconde

Snowflake ID Berekeningsproces

Het Snowflake ID generatie algoritme volgt deze precieze stappen:

Haal Huidige Tijdstempel Op: Verkrijg de huidige tijd in milliseconden
Zorg Voor Chronologische Volgorde: Controleer of de tijdstempel groter is dan de laatst gebruikte tijdstempel
Behandel Zelfde Tijdstempel: Als de tijdstempel overeenkomt met de vorige, verhoog het volgnummer
Voorkom Overloop: Als de volgnummer 4096 bereikt, wacht dan op de volgende milliseconde
Combineer Componenten: Gebruik bitwise operaties om de uiteindelijke unieke ID te creëren

Dit proces garandeert monotonisch toenemende IDs binnen elke machine terwijl de globale uniekheid over gedistribueerde systemen behouden blijft.

Snowflake ID Toepassingen en Toepassingen

Snowflake IDs excelleren in verschillende gedistribueerde computer scenario's:

Primaire Toepassingen

Gedistribueerde Systemen: Genereer unieke IDs over meerdere machines zonder coördinatie
Hoge Volume Data Verwerking: Maak sorteerebare IDs voor enorme datasets
Microservices Architectuur: Zorg voor unieke identifiers over verschillende diensten
Database Sharding: Gebruik tijdstempel of machine-ID componenten voor efficiënte datapartitionering

Toepassingen in de Praktijk

Sociale Media Platforms: Twitter, Instagram voor post- en gebruikers-ID's
E-commerce Systemen: Ordertracking en voorraadbeheer
IoT Gegevensverzameling: Apparatuur gebeurtenislogging en sensorgegevens
Financiële Systemen: Transactie verwerking en audit trails

Snowflake ID Alternatieven en Vergelijkingen

Hoewel Snowflake IDs krachtig zijn, omvatten andere unieke ID generatie systemen:

Alternatieve ID Systemen

UUID (Universally Unique Identifier): Het beste voor gedistribueerde generatie zonder sorteereisen
Auto-incrementerende Database IDs: Eenvoudige oplossing beperkt tot enkele database-instanties
ULID (Universally Unique Lexicographically Sortable Identifier): Vergelijkbaar met Snowflake met base32 codering
NanoID: Compacte, URL-veilige unieke string generator voor webapplicaties

Snowflake ID Beperkingen en Overwegingen

Het begrijpen van Snowflake ID beperkingen helpt bij een goede implementatie:

Veelvoorkomende Uitdagingen

Klok Synchronisatie Problemen: Systeem tijdsafhankelijkheden kunnen problemen veroorzaken met NTP-aanpassingen of veranderingen in de zomertijd
Beperking Jaar 2079: 41-bits tijdstempel overflow vereist langetermijnplanning voor systemen met hoge schaal
Machine ID Beheer: Zorgen voor unieke machine-ID's over grote gedistribueerde systemen vereist coördinatie
Volgnummer Overflow: Uiterst hoge doorvoerscenario's kunnen 4096 volgnummers per milliseconde uitputten
Cross-Machine Volgorde: IDs zijn monotonisch per machine maar niet globaal over alle machines

Geschiedenis van Snowflake IDs

Snowflake IDs werden geïntroduceerd door Twitter in 2010 om de uitdaging aan te gaan van het genereren van gedistribueerde, tijd-sortable unieke identifiers op enorme schaal. Toen de gebruikersbasis van Twitter en het aantal tweets explodeerde, werden traditionele auto-incrementerende IDs onvoldoende voor hun gedistribueerde architectuur.

Het systeem is sindsdien overgenomen door grote technologiebedrijven, waaronder Instagram, Discord en talloze andere platforms die schaalbare ID-generatie voor gedistribueerde systemen vereisen.

Snowflake ID Generator Code Voorbeelden

Implementeer Snowflake ID generatie in je favoriete programmeertaal:

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('Klok is teruggezet. Weigeren om id te genereren');
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// Gebruik
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Gegenereerde Snowflake 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("Klok is teruggezet. Weigeren om id te genereren")
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## Gebruik
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Gegenereerde Snowflake 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 kan niet groter zijn dan maxDatacenterId of kleiner dan 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId kan niet groter zijn dan maxWorkerId of kleiner dan 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("Klok is teruggezet. Weigeren om id te genereren");
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("Gegenereerde Snowflake ID: " + id);
91    }
92}
93

1require 'time'
2
3class SnowflakeGenerator
4  def initialize(datacenter_id, worker_id, sequence = 0)
5    @datacenter_id = datacenter_id
6    @worker_id = worker_id
7    @sequence = sequence
8    @last_timestamp = -1
9    @epoch = 1288834974657
10
11    @datacenter_id_bits = 5
12    @worker_id_bits = 5
13    @sequence_bits = 12
14
15    @max_datacenter_id = -1 ^ (-1 << @datacenter_id_bits)
16    @max_worker_id = -1 ^ (-1 << @worker_id_bits)
17
18    @worker_id_shift = @sequence_bits
19    @datacenter_id_shift = @sequence_bits + @worker_id_bits
20    @timestamp_left_shift = @sequence_bits + @worker_id_bits + @datacenter_id_bits
21    @sequence_mask = -1 ^ (-1 << @sequence_bits)
22  end
23
24  def next_id
25    timestamp = (Time.now.to_f * 1000).to_i
26
27    raise 'Klok is teruggezet' if timestamp < @last_timestamp
28
29    if timestamp == @last_timestamp
30      @sequence = (@sequence + 1) & @sequence_mask
31      timestamp = til_next_millis(@last_timestamp) if @sequence == 0
32    else
33      @sequence = 0
34    end
35
36    @last_timestamp = timestamp
37
38    ((timestamp - @epoch) << @timestamp_left_shift) |
39      (@datacenter_id << @datacenter_id_shift) |
40      (@worker_id << @worker_id_shift) |
41      @sequence
42  end
43
44  private
45
46  def til_next_millis(last_timestamp)
47    timestamp = (Time.now.to_f * 1000).to_i
48    timestamp = (Time.now.to_f * 1000).to_i while timestamp <= last_timestamp
49    timestamp
50  end
51end
52
53## Gebruik
54generator = SnowflakeGenerator.new(1, 1)
55snowflake_id = generator.next_id
56puts "Gegenereerde Snowflake ID: #{snowflake_id}"
57

<?php

class SnowflakeGenerator {
    private $epoch;
    private $datacenterIdBits;
    private $workerIdBits;
    private $sequenceBits;
    private $maxDatacenterId;
    private $maxWorkerId;
    private $workerIdShift;
    private $datacenterIdShift;
    private $timestampLeftShift;
    private $sequenceMask;

    private $datacenterId;
    private $workerId;
    private $sequence = 0;
    private $lastTimestamp = -1;

    public function __construct($datacenterId, $workerId) {
        $this->epoch = 1288834974657;
        $this->datacenterIdBits = 5;
        $this->workerIdBits = 5;
        $this->sequenceBits = 12;

        $this->maxDatacenterId = -1 ^ (-1 << $this->datacenterIdBits);
        $this->maxWorkerId = -1 ^ (-1 << $this->workerIdBits);

        $this->workerIdShift = $this->sequenceBits;
        $this->datacenterIdShift = $this->sequenceBits + $this->workerIdBits;
        $this->timestampLeftShift = $this->sequenceBits + $this->workerIdBits + $this->datacenterIdBits;
        $this->sequenceMask = -1 ^ (-1 << $this->sequenceBits);

        if ($datacenterId > $this->maxDatacenterId || $datacenterId < 0) {
            throw new Exception("datacenterId kan niet groter zijn dan maxDatacenterId of kleiner dan 0");
        }
        if ($workerId > $this->maxWorkerId || $workerId < 0) {
            throw new Exception("workerId kan niet groter zijn dan maxWorkerId of kleiner dan

Whiz Tools

Genereer en Analyseer Twitter Snowflake ID Tool voor Inzichten

Snowflake ID-generator