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("Az óra visszafelé mozdult. Az ID generálásának megtagadása")
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## Használat
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"Generált 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 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("Az óra visszafelé mozdult. Az ID generálásának megtagadása");
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("Generált 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    @datacenter_id_bits = 5
11    @worker_id_bits = 5
12    @sequence_bits = 12
13    @max_datacenter_id = -1 ^ (-1 << @datacenter_id_bits)
14    @max_worker_id = -1 ^ (-1 << @worker_id_bits)
15    @worker_id_shift = @sequence_bits
16    @datacenter_id_shift = @sequence_bits + @worker_id_bits
17    @timestamp_left_shift = @sequence_bits + @worker_id_bits + @datacenter_id_bits
18    @sequence_mask = -1 ^ (-1 << @sequence_bits)
19  end
20
21  def next_id
22    timestamp = (Time.now.to_f * 1000).to_i
23    raise 'Az óra visszafelé mozdult' if timestamp < @last_timestamp
24
25    if timestamp == @last_timestamp
26      @sequence = (@sequence + 1) & @sequence_mask
27      timestamp = til_next_millis(@last_timestamp) if @sequence == 0
28    else
29      @sequence = 0
30    end
31
32    @last_timestamp = timestamp
33
34    ((timestamp - @epoch) << @timestamp_left_shift) |
35      (@datacenter_id << @datacenter_id_shift) |
36      (@worker_id << @worker_id_shift) |
37      @sequence
38  end
39
40  private
41
42  def til_next_millis(last_timestamp)
43    timestamp = (Time.now.to_f * 1000).to_i
44    timestamp = (Time.now.to_f * 1000).to_i while timestamp <= last_timestamp
45    timestamp
46  end
47end
48
49## Használat
50generator = SnowflakeGenerator.new(1, 1)
51snowflake_id = generator.next_id
52puts "Generált Snowflake ID: #{snowflake_id}"
53

1<?php
2
3class SnowflakeGenerator {
4    private $epoch;
5    private $datacenterIdBits;
6    private $workerIdBits;
7    private $sequenceBits;
8    private $maxDatacenterId;
9    private $maxWorkerId;
10    private $workerIdShift;
11    private $datacenterIdShift;
12    private $timestampLeftShift;
13    private $sequenceMask;
14
15    private $datacenterId;
16    private $workerId;
17    private $sequence = 0;
18
19    private $lastTimestamp = -1;
20
21    public function __construct($datacenterId, $workerId) {
22        $this->epoch = 1288834974657;
23        $this->datacenterIdBits = 5;
24        $this->workerIdBits = 5;
25        $this->sequenceBits = 12;
26
27        $this->maxDatacenterId = -1 ^ (-1 << $this->datacenterIdBits);
28        $this->maxWorkerId = -1 ^ (-1 << $this->workerIdBits);
29
30        $this->workerIdShift = $this->sequenceBits;
31        $this->datacenterIdShift = $this->sequenceBits + $this->workerIdBits;
32        $this->timestampLeftShift = $this->sequenceBits + $this->workerIdBits + $this->datacenterIdBits;
33        $this->sequenceMask = -1 ^ (-1 << $this->sequenceBits);
34
35        if ($datacenterId > $this->maxDatacenterId || $datacenterId < 0) {
36            throw new Exception("datacenterId can't be greater than maxDatacenterId or less than 0");
37        }
38        if ($workerId > $this->maxWorkerId || $workerId < 0) {
39            throw new Exception("workerId can't be greater than maxWorkerId or less than 0");
40        }
41        $this->datacenterId = $datacenterId;
42        $this->workerId = $workerId;
43    }
44
45    public function nextId() {
46        $timestamp = $this->timeGen();
47
48        if ($timestamp < $this->lastTimestamp) {
49            throw new Exception("Az óra visszafelé mozdult. Az ID generálásának megtagadása");
50        }
51
52        if ($this->lastTimestamp == $timestamp) {
53            $this->sequence = ($this->sequence + 1) & $this->sequenceMask;
54            if ($this->sequence == 0) {
55                $timestamp = $this->tilNextMillis($this->lastTimestamp);
56            }
57        } else {
58            $this->sequence = 0;
59        }
60
61        $this->lastTimestamp = $timestamp;
62
63        return (($timestamp - $this->epoch) << $this->timestampLeftShift) |
64               ($this->datacenterId << $this->datacenterIdShift) |
65               ($this->workerId << $this->workerIdShift) |
66               $this->sequence;
67    }
68
69    private function tilNextMillis($lastTimestamp) {
70        $timestamp = $this->timeGen();
71        while ($timestamp <= $lastTimestamp) {
72            $timestamp = $this->timeGen();
73        }
74        return $timestamp;
75    }
76
77    private function timeGen() {
78        return floor(microtime(true) * 1000);
79    }
80}
81
82// Használat
83$generator = new SnowflakeGenerator(1, 1);
84$id = $generator->nextId();
85echo "Generált Snowflake ID: " . $id . "\n";
86

1using System;
2using System.Threading;
3
4public class SnowflakeGenerator
5{
6    private readonly long _epoch;
7    private readonly int _datacenterIdBits;
8    private readonly int _workerIdBits;
9    private readonly int _sequenceBits;
10    private readonly long _maxDatacenterId;
11    private readonly long _maxWorkerId;
12    private readonly int _workerIdShift;
13    private readonly int _datacenterIdShift;
14    private readonly int _timestampLeftShift;
15    private readonly long _sequenceMask;
16
17    private readonly long _datacenterId;
18    private readonly long _workerId;
19    private long _sequence = 0L;
20    private long _lastTimestamp = -1L;
21
22    private readonly object _lock = new object();
23
24    public SnowflakeGenerator(long datacenterId, long workerId)
25    {
26        _epoch = 1288834974657L;
27        _datacenterIdBits = 5;
28        _workerIdBits = 5;
29        _sequenceBits = 12;
30
31        _maxDatacenterId = -1L ^ (-1L << _datacenterIdBits);
32        _maxWorkerId = -1L ^ (-1L << _workerIdBits);
33
34        _workerIdShift = _sequenceBits;
35        _datacenterIdShift = _sequenceBits + _workerIdBits;
36        _timestampLeftShift = _sequenceBits + _workerIdBits + _datacenterIdBits;
37        _sequenceMask = -1L ^ (-1L << _sequenceBits);
38
39        if (datacenterId > _maxDatacenterId || datacenterId < 0)
40        {
41            throw new ArgumentException($"datacenterId can't be greater than {_maxDatacenterId} or less than 0");
42        }
43        if (workerId > _maxWorkerId || workerId < 0)
44        {
45            throw new ArgumentException($"workerId can't be greater than {_maxWorkerId} or less than 0");
46        }
47        _datacenterId = datacenterId;
48        _workerId = workerId;
49    }
50
51    public long NextId()
52    {
53        lock (_lock)
54        {
55            var timestamp = TimeGen();
56
57            if (timestamp < _lastTimestamp)
58            {
59                throw new Exception("Az óra visszafelé mozdult. Az ID generálásának megtagadása");
60            }
61
62            if (_lastTimestamp == timestamp)
63            {
64                _sequence = (_sequence + 1) & _sequenceMask;
65                if (_sequence == 0)
66                {
67                    timestamp = TilNextMillis(_lastTimestamp);
68                }
69            }
70            else
71            {
72                _sequence = 0L;
73            }
74
75            _lastTimestamp = timestamp;
76
77            return ((timestamp - _epoch) << _timestampLeftShift) |
78                   (_datacenterId << _datacenterIdShift) |
79                   (_workerId << _workerIdShift) |
80                   _sequence;
81        }
82    }
83
84    private long TilNextMillis(long lastTimestamp)
85    {
86        var timestamp = TimeGen();
87        while (timestamp <= lastTimestamp)
88        {
89            timestamp = TimeGen();
90        }
91        return timestamp;
92    }
93
94    private long TimeGen()
95    {
96        return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
97    }
98}
99
100// Használat
101class Program
102{
103    static void Main(string[] args)
104    {
105        var generator = new SnowflakeGenerator(1, 1);
106        var id = generator.NextId();
107        Console.WriteLine($"Generált Snowflake ID: {id}");
108    }
109}
110

1package main
2
3import (
4	"fmt"
5	"sync"
6	"time"
7)
8
9type SnowflakeGenerator struct {
10	epoch             int64
11	datacenterIdBits  uint
12	workerIdBits      uint
13	sequenceBits      uint
14	maxDatacenterId   int64
15	maxWorkerId       int64
16	workerIdShift     uint
17	datacenterIdShift uint
18	timestampLeftShift uint
19	sequenceMask      int64
20
21	datacenterId int64
22	workerId     int64
23	sequence     int64
24	lastTimestamp int64
25
26	lock sync.Mutex
27}
28
29func NewSnowflakeGenerator(datacenterId, workerId int64) (*SnowflakeGenerator, error) {
30	g := &SnowflakeGenerator{
31		epoch:             1288834974657,
32		datacenterIdBits:  5,
33		workerIdBits:      5,
34		sequenceBits:      12,
35		lastTimestamp:     -1,
36	}
37
38	g.maxDatacenterId = -1 ^ (-1 << g.datacenterIdBits)
39	g.maxWorkerId = -1 ^ (-1 << g.workerIdBits)
40
41	g.workerIdShift = g.sequenceBits
42	g.datacenterIdShift = g.sequenceBits + g.workerIdBits
43	g.timestampLeftShift = g.sequenceBits + g.workerIdBits + g.datacenterIdBits
44	g.sequenceMask = -1 ^ (-1 << g.sequenceBits)
45
46	if datacenterId > g.maxDatacenterId || datacenterId < 0 {
47		return nil, fmt.Errorf("datacenterId can't be greater than %d or less than 0", g.maxDatacenterId)
48	}
49	if workerId > g.maxWorkerId || workerId < 0 {
50		return nil, fmt.Errorf("workerId can't be greater than %d or less than 0", g.maxWorkerId)
51	}
52	g.datacenterId = datacenterId
53	g.workerId = workerId
54
55	return g, nil
56}
57
58func (g *SnowflakeGenerator) NextId() (int64, error) {
59	g.lock.Lock()
60	defer g.lock.Unlock()
61
62	timestamp := g.timeGen()
63
64	if timestamp < g.lastTimestamp {
65		return 0, fmt.Errorf("az óra visszafelé mozdult, az ID generálásának megtagadása")
66	}
67
68	if g.lastTimestamp == timestamp {
69		g.sequence = (g.sequence + 1) & g.sequenceMask
70		if g.sequence == 0 {
71			timestamp = g.tilNextMillis(g.lastTimestamp)
72		}
73	} else {
74		g.sequence = 0
75	}
76
77	g.lastTimestamp = timestamp
78
79	return ((timestamp - g.epoch) << g.timestampLeftShift) |
80		(g.datacenterId << g.datacenterIdShift) |
81		(g.workerId << g.workerIdShift) |
82		g.sequence, nil
83}
84
85func (g *SnowflakeGenerator) tilNextMillis(lastTimestamp int64) int64 {
86	timestamp := g.timeGen()
87	for timestamp <= lastTimestamp {
88		timestamp = g.timeGen()
89	}
90	return timestamp
91}
92
93func (g *SnowflakeGenerator) timeGen() int64 {
94	return time.Now().UnixNano() / int64(time.Millisecond)
95}
96
97func main() {
98	generator, err := NewSnowflakeGenerator(1, 1)
99	if err != nil {
100		fmt.Printf("Hiba a generátor létrehozásakor: %v\n", err)
101		return
102	}
103
104	id, err := generator.NextId()
105	if err != nil {
106		fmt.Printf("Hiba az ID generálásakor: %v\n", err)
107		return
108	}
109
110	fmt.Printf("Generált Snowflake ID: %d\n", id)
111}
112