Lumihiutale ID -generaattori: Luo ainutlaatuisia hajautettuja järjestelmäidentifikaattoreita

Mikä on Lumihiutale ID -generaattori?

Lumihiutale ID -generaattori luo ainutlaatuisia tunnisteita hajautetuille järjestelmille, joka on alun perin kehitetty Twitterissä käsittelemään valtavia tietojenkäsittelymääriä. Tämä tehokas ainutlaatuinen ID -generaattori tuottaa 64-bittisiä kokonaislukuja, jotka koostuvat aikaleimasta, koneen ID:stä ja sekvenssinumerosta, varmistaen ainutlaatuisuuden hajautetuissa järjestelmissä ilman palvelimien välistä koordinointia.

Ilmainen online Lumihiutale ID -generaattorimme mahdollistaa Lumihiutale ID:iden luomisen ja jäsentämisen välittömästi, mikä tekee siitä täydellisen kehittäjille, jotka työskentelevät mikropalveluiden, hajautettujen tietokantojen ja suuritehoisten sovellusten parissa.

Kuinka Lumihiutale ID -generaattori toimii

Lumihiutale ID:t ovat 64-bittisiä kokonaislukuja, joilla on huolellisesti suunniteltu rakenne, joka takaa ainutlaatuisuuden:

41 bittiä: Aikaleima (millisekunnit mukautetusta aikakaudesta)
10 bittiä: Koneen ID (5 bittiä datakeskuksen ID:lle, 5 bittiä työntekijän ID:lle)
12 bittiä: Sekvenssinumero

Tämä hajautettu ID-rakenne mahdollistaa noin 4 096 ainutlaatuisen ID:n luomisen millisekunnissa per kone, mikä tekee siitä ihanteellisen suuritehoisille hajautetuille järjestelmille.

Kuinka käyttää Lumihiutale ID -generaattoriamme

Seuraa näitä yksinkertaisia vaiheita luodaksesi ainutlaatuisia Lumihiutale ID:itä:

Aseta mukautettu aikakausi (valinnainen): Käytä oletus Twitter-aikakautta (2010-11-04T01:42:54.657Z) tai määritä oma
Määritä koneen ID:t: Syötä koneen ID (0-31) ja datakeskuksen ID (0-31)
Luo ID: Napsauta "Luo" luodaksesi uuden ainutlaatuisen Lumihiutale ID:n
Näytä tulokset: Katso luotu ID ja sen komponenttien erittely

Jäsennä olemassa olevat Lumihiutale ID:t

Dekoodataksesi Lumihiutale ID:n, syötä se "Jäsennä ID" -kenttään ja napsauta "Jäsennä" nähdäksesi sen aikaleiman, koneen ID:n ja sekvenssikomponentit.

Lumihiutale ID -generaation kaava

Lumihiutale ID -algoritmi rakentaa ainutlaatuisia tunnisteita bittitasolla:

1ID = (aikaleima << 22) | (datakeskuksenId << 17) | (työntekijänId << 12) | sekvenssi
2

Kaavan komponentit:

aikaleima: Millisekuntien määrä aikakaudesta
datakeskuksenId: 5-bittinen kokonaisluku (0-31), joka tunnistaa datakeskuksen
työntekijänId: 5-bittinen kokonaisluku (0-31), joka tunnistaa työntekijäkoneen
sekvenssi: 12-bittinen kokonaisluku (0-4095) useille ID:ille millisekunnissa

Lumihiutale ID -laskentaprosessi

Lumihiutale ID -generaation algoritmi seuraa näitä tarkkoja vaiheita:

Hanki nykyinen aikaleima: Hae nykyinen aika millisekunneissa
Varmista aikajärjestys: Varmista, että aikaleima ylittää viimeksi käytetyn aikaleiman
Käsittele sama aikaleima: Jos aikaleima vastaa edellistä, lisää sekvenssinumeroa
Estä ylivuoto: Jos sekvenssi saavuttaa 4096, odota seuraavaa millisekuntia
Yhdistä komponentit: Käytä bittitasolla toimintoja luodaksesi lopullinen ainutlaatuinen ID

Tämä prosessi takaa monotonisesti kasvavat ID:t jokaisessa koneessa samalla kun se säilyttää globaalin ainutlaatuisuuden hajautetuissa järjestelmissä.

Lumihiutale ID -käyttötapaukset ja sovellukset

Lumihiutale ID:t erottuvat erilaisissa hajautetun laskennan skenaarioissa:

Pääkäyttötapaukset

Hajautetut järjestelmät: Luo ainutlaatuisia ID:itä useilla koneilla ilman koordinointia
Suuri tietojenkäsittely: Luo lajiteltavia ID:itä suurille tietojoukoille
Mikropalveluarkkitehtuuri: Varmista ainutlaatuiset tunnisteet eri palveluiden välillä
Tietokannan jakaminen: Käytä aikaleima- tai koneen ID -komponentteja tehokkaaseen tietojen jakamiseen

Todelliset sovellukset

Sosiaalisen median alustat: Twitter, Instagram postien ja käyttäjien ID:ille
Verkkokauppajärjestelmät: Tilausten seuranta ja varastonhallinta
IoT-tietojen keruu: Laitteen tapahtumalokit ja anturidata
Rahoitusjärjestelmät: Transaktioiden käsittely ja tarkastuspolut

Lumihiutale ID -vaihtoehdot ja vertailut

Vaikka Lumihiutale ID:t ovat tehokkaita, muita ainutlaatuisia ID-generaatiomenetelmiä ovat:

Vaihtoehtoiset ID-järjestelmät

UUID (Universally Unique Identifier): Paras hajautettuun luontiin ilman lajittelutarpeita
Automaattisesti kasvavat tietokanta-ID:t: Yksinkertainen ratkaisu, joka rajoittuu yksittäisiin tietokanta-instansseihin
ULID (Universally Unique Lexicographically Sortable Identifier): Samankaltainen kuin Lumihiutale, mutta base32-koodauksella
NanoID: Kompakti, URL-turvallinen ainutlaatuinen merkkijonogeneraattori verkkosovelluksille

Lumihiutale ID -rajoitukset ja huomioitavat seikat

Ymmärtäminen Lumihiutale ID -rajoituksista auttaa oikeassa toteutuksessa:

Yleiset haasteet

Kellon synkronointiongelmat: Järjestelmän aikariippuvuudet voivat aiheuttaa ongelmia NTP-säätöjen tai kesäaikamuutosten kanssa
Vuoden 2079 rajoitus: 41-bittinen aikaleiman ylivuoto vaatii pitkän aikavälin suunnittelua suurilla järjestelmillä
Koneen ID:n hallinta: Ainutlaatuisten koneen ID:iden varmistaminen suurissa hajautetuissa järjestelmissä vaatii koordinointia
Sekvenssin ylivuoto: Erittäin suuritehoisissa skenaarioissa 4096 sekvenssiä millisekunnissa voi loppua
Koneiden välinen järjestys: ID:t ovat monotonisia per kone, mutta eivät globaalisti kaikkien koneiden välillä

Lumihiutale ID -historia

Lumihiutale ID:t esiteltiin Twitterissä vuonna 2010 ratkaisemaan haasteen luoda hajautettuja, aikajärjestykseen perustuvia ainutlaatuisia tunnisteita valtavassa mittakaavassa. Kun Twitterin käyttäjäkunta ja twiittien määrä kasvoivat räjähdysmäisesti, perinteiset automaattisesti kasvavat ID:t eivät riittäneet heidän hajautettuun arkkitehtuuriinsa.

Järjestelmää on sittemmin ottanut käyttöön useat suuret teknologiayritykset, kuten Instagram, Discord ja lukemattomat muut alustat, jotka tarvitsevat skaalautuvaa ID-generaatiota hajautetuissa järjestelmissä.

Lumihiutale ID -generaattorin koodiesimerkit

Toteuta Lumihiutale ID -generaatiota haluamassasi ohjelmointikielessä:

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('Kello siirtyi taaksepäin. Kieltäydyn luomasta id:tä');
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// Käyttö
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`Luotu Lumihiutale 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("Kello siirtyi taaksepäin. Kieltäydyn luomasta id:tä")
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## Käyttö
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Luotu Lumihiutale 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 ei voi olla suurempi kuin maxDatacenterId tai pienempi kuin 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId ei voi olla suurempi kuin maxWorkerId tai pienempi kuin 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("Kello siirtyi taaksepäin. Kieltäydyn luomasta id:tä");
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("Luotu Lumihiutale 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 'Kello siirtyi taaksepäin' if timestamp < @last_timestamp

    if timestamp == @last_timestamp
      @sequence = (@sequence + 1

Whiz Tools

Generoi ja analysoi Twitter Snowflake ID -työkalua oivalluksia varten

Lumisateen ID-generaattori

Lumisateen ID-generaattori

Dokumentaatio

Lumihiutale ID -generaattori: Luo ainutlaatuisia hajautettuja järjestelmäidentifikaattoreita

Mikä on Lumihiutale ID -generaattori?

Kuinka Lumihiutale ID -generaattori toimii

Kuinka käyttää Lumihiutale ID -generaattoriamme

Jäsennä olemassa olevat Lumihiutale ID:t

Lumihiutale ID -generaation kaava

Lumihiutale ID -laskentaprosessi

Lumihiutale ID -käyttötapaukset ja sovellukset

Pääkäyttötapaukset

Todelliset sovellukset

Lumihiutale ID -vaihtoehdot ja vertailut

Vaihtoehtoiset ID-järjestelmät

Lumihiutale ID -rajoitukset ja huomioitavat seikat

Yleiset haasteet

Lumihiutale ID -historia

Lumihiutale ID -generaattorin koodiesimerkit

Liittyvät Työkalut

UUID-generaattori: Luo ainutlaatuisia tunnisteita helposti

Nano ID - Luo turvallisia URL-yhteensopivia ainutlaatuisia tunnisteita

Satunnainen Projektin Nimen Generaattori

Satunnainen käyttäjäagentin generaattori verkkokehityksen testaamiseen

Satunnainen API-avainten generaattori: Luo turvallisia 32-merkkisiä merkkijonoja

Satunnaisten CPF-numeroiden generaattori testaukseen

Satunnainen sijaintigeneraattori: Maailman koordinaattien luoja

MD5-hashin generaattori

Tehokas KSUID-generaattori ainutlaatuisille tunnisteille järjestelmissä

Vauvan Nimen Generaattori Kategorioilla - Löydä Täydellinen Nimi