有两个思路：
1使用散列函数，如sha256，加上时间戳、mac地址、cpu负荷、随机数等组成，id足够长，引入多个不确定因素，以至于碰撞几率非常小，可以认为是全局唯一。例如uuid就是这种。但是uuid是字符串的形式，对于DB来说，占用的空间至少大一倍，DB的索引是需要存储和对比的，因此在存储空间和查询时间上面都比整形要低，这种情况在DB的数据条数越多时越明显。
2使用分割法。每个节点都保证自己生成的所有id在本机唯一，每个节点都有一个人为分配的不重复节点编号，插入id中，这样所有节点的id都是全局唯一的。
3利用DB自带的主键唯一性来确保id唯一。但是db的自增id是需要等到事务提交后，ID才算是有效的。有些双向引用的数据，不得不插入后再做一次更新，比较麻烦。
第二种方式是类似Twitter的Snowflake算法，它给每台机器分配一个唯一标识，然后通过时间戳+标识+自增实现全局唯一ID。这种方式好处在于ID生成算法完全是一个无状态机，无网络调用，高效可靠。缺点是如果唯一标识有重复，会造成ID冲突。
Snowflake算法采用41bit毫秒时间戳，加上10bit机器ID（最多支持1024台id服务器），加上12bit序列号，理论上最多支持1024台机器每秒生成4096000个序列号。409万个id每秒，在任何交易平台目前都是够用的。

推特的id构成（从最高位往最低位方向）：

1位 ，不用。固定是0
41位 ，毫秒时间戳
5位 ，数据中心ID (用于对数据中心进行编码)
5位 ，WORKERID (用于对工作进程进行编码)
12位 ，序列号。用于同一毫秒产生ID的序列 （自增id）
下面是用golang实现的uuid方法(uuid类型为整形)：

  1. package main
  3. import (
  4.     "fmt"
  6.     idworker "github.com/gitstliu/go-id-worker"
  7. )
  9. func main() {
  10.     currWoker := &idworker.IdWorker{}
  11.     currWoker.InitIdWorker(1000, 1)
  12.     newID, err := currWoker.NextId()
  13.     if err == nil {
  14.         fmt.Println(newID)
  15.     }
  16. }

下载库
go get github.com/gitstliu/go-id-worker
下面是在vscode中的调试结果
API server listening at: 127.0.0.1:4442
4917572028174794752
Process exiting with code: 0

用mysql自带的自增id生成全局唯一id

  1. package main
  3. import (
  4.     "database/sql"
  5.     "errors"
  6.     "log"
  7.     "time"
  8.     "fmt"
  9.     _ "github.com/go-sql-driver/mysql"
  10. )
  13. type logger interface {
  14.     Error(error)
  15. }
  17. // Logger Log接口，如果设置了Logger，就使用Logger打印日志，如果没有设置，就使用内置库log打印日志
  18. var Logger logger
  20. // ErrTimeOut 获取uid超时错误
  21. var ErrTimeOut = errors.New("get uid timeout")
  23. type Uid struct {
  24.     db         *sql.DB    // 数据库连接
  25.     businessId string     // 业务id
  26.     ch         chan int64 // id缓冲池
  27.     min, max   int64      // id段最小值，最大值
  28. }
  30. // NewUid 创建一个Uid;len：缓冲池大小()
  31. // db:数据库连接
  32. // businessId：业务id
  33. // len：缓冲池大小(长度可控制缓存中剩下多少id时，去DB中加载)
  34. func NewUid(db *sql.DB, businessId string, len int) (*Uid, error) {
  35.     lid := Uid{
  36.         db:         db,
  37.         businessId: businessId,
  38.         ch:         make(chan int64, len),
  39.     }
  40.     go lid.productId()
  41.     return &lid, nil
  42. }
  44. // Get 获取自增id,当发生超时，返回错误，避免大量请求阻塞，服务器崩溃
  45. func (u *Uid) Get() (int64, error) {
  46.     select {
  47.     case <-time.After(1 * time.Second):
  48.         return 0, ErrTimeOut
  49.     case uid := <-u.ch:
  50.         return uid, nil
  51.     }
  52. }
  54. // productId 生产id，当ch达到最大容量时，这个方法会阻塞，直到ch中的id被消费
  55. func (u *Uid) productId() {
  56.     u.reLoad()
  58.     for {
  59.         if u.min >= u.max {
  60.             u.reLoad()
  61.         }
  63.         u.min++
  64.         u.ch <- u.min
  65.     }
  66. }
  68. // reLoad 在数据库获取id段，如果失败，会每隔一秒尝试一次
  69. func (u *Uid) reLoad() error {
  70.     var err error
  71.     for {
  72.         err = u.getFromDB()
  73.         if err == nil {
  74.             return nil
  75.         }
  77.         // 数据库发生异常，等待一秒之后再次进行尝试
  78.         if Logger != nil {
  79.             Logger.Error(err)
  80.         } else {
  81.             log.Println(err)
  82.         }
  83.         time.Sleep(time.Second)
  84.     }
  85. }
  87. // getFromDB 从数据库获取id段
  88. func (u *Uid) getFromDB() error {
  89.     var (
  90.         maxId int64
  91.         step  int64
  92.     )    
  94.     row := u.db.QueryRow("SELECT max_id, step FROM uid;")
  95.     //row = u.db.QueryRow("SELECT max_id, step FROM uid WHERE business_id = ? FOR UPDATE",1)
  96.     if err :=row.Scan(&maxId, &step); err != nil{
  97.         fmt.Printf("scan failed, err:%v",err)
  98.         return err
  99.     }
  101.     _, err := u.db.Exec("UPDATE uid SET max_id = ?", maxId+step)
  102.     if err != nil {
  103.         return err
  104.     }
  105.     u.min = maxId
  106.     u.max = maxId + step    
  108.     return nil
  109. }
  112. const (
  113.     DeviceIdBusinessId = "device_id" // 设备id
  114. )
  116. var(
  117.     DeviceIdUid      *Uid
  118. )
  120. func InitUID(db *sql.DB) {
  121.     var err error
  122.     DeviceIdUid, err = NewUid(db, DeviceIdBusinessId, 5)
  123.     if err != nil {
  124.         panic(err)
  125.     }
  126. }
  129. func check(err error) {
  130.     if err != nil {
  131.         panic(err)
  132.     }
  133. }
  135. const (
  136.     USER_NAME = "root"
  137.     PASS_WORD = "123456"
  138.     HOST      = "localhost"
  139.     PORT      = "3306"
  140.     DATABASE  = "test"
  141.     CHARSET   = "utf8"
  142. )
  144. // 
  145. func main() {
  146.     // http init
  148.     // http api goroutine
  150.     url := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s", USER_NAME, PASS_WORD, HOST, PORT, DATABASE, CHARSET)
  152.     db, err := sql.Open("mysql", url)
  153.     if err != nil {
  154.         panic(err)
  155.     }    
  156.     InitUID(db)
  159.     for i:=0; i<20; i++ {
  160.         id ,err := DeviceIdUid.Get()
  161.         if err == nil {
  162.             fmt.Println("id=", id)
  163.         } else {
  164.             fmt.Println(err)
  165.         }
  166.     }
  168. }

测试结果：

  1. [root@bogon uid]# go build main.go 
  2. [root@bogon uid]# ./main 
  3. id= 1706
  4. id= 1707
  5. id= 1708
  6. id= 1709
  7. id= 1710
  8. id= 1711
  9. id= 1712
  10. id= 1713
  11. id= 1714
  12. id= 1715
  13. id= 1716
  14. id= 1717
  15. id= 1718
  16. id= 1719
  17. id= 1720
  18. id= 1721
  19. id= 1722
  20. id= 1723
  21. id= 1724
  22. id= 1725
  23. [root@bogon uid]#


以下为uid服务器的架构图：
golang实现全局唯一id snowflake算法 - 图1

原文链接：https://blog.csdn.net/jacky128256/java/article/details/104687772