go生成随机数

func GeRnd() string {
    b := make([]byte, 8)
    rand.Read(b)
    return fmt.Sprintf("%x", b)
}

// RndInt 生成 [start, end]的随机数
func RndInt(start, end int) int {
    du := end - start + 1
    rand.Seed(time.Now().UnixNano())
    return start + rand.Intn(du)
}

max := int64(10000)
nBig, err := rand.Int(rand.Reader, big.NewInt(max))
if err != nil {
    log.Println(err)
}
ret := nBig.Int64()

package snowflake

import (
    "crypto/rand"
    "log"
    "math"
    "math/big"
    "sync"
    "time"
)

const (
    WORKER_ID_LEN uint  = 14
    FLOW_LEN      uint  = 22 - WORKER_ID_LEN // 8
    INIT_TIME     int64 = 1420041600000
    FLOWMAX       int64 = 256 // 2^FLOW_LEN
)

// SnowFlake 生成分布式流水号
// 0位  时间     workerID        流水号
// 0 - 0 * 41 - 0 * 14 - 0 * 8
type SnowFlake struct {
    workerID int64
    lastTp   int64
    flow     int64
    lk       sync.Mutex
}

func (s *SnowFlake) getWorkerID() int64 {
    if s.workerID != 0 {
        return s.workerID
    }
    max := int64(math.Pow(2, float64(WORKER_ID_LEN)))
    nBig, err := rand.Int(rand.Reader, big.NewInt(max))
    if err != nil {
        log.Println(err)
    }
    ret := nBig.Int64()

    s.workerID = ret
    return s.workerID
}

func (s *SnowFlake) generate(t time.Time) int64 {
    s.lk.Lock()
    defer s.lk.Unlock()

    tp := t.UnixNano() / 1e6
    tp = tp - INIT_TIME

    if tp == s.lastTp {
        s.flow++

        if s.flow > FLOWMAX {
            panic("flow number overflowed")
        }
    } else if tp < s.lastTp {
        // ntpd 对时间进行了回拔，此时必须重新生成 worker_id
        s.workerID = 0
        s.lastTp = tp
        s.flow = 0
    } else {
        s.lastTp = tp
        s.flow = 0
    }

    var ret int64

    ret += tp << (WORKER_ID_LEN + FLOW_LEN)
    ret += s.getWorkerID() << (FLOW_LEN)
    ret += s.flow

    return ret
}

// GetTime 传入一个id，显示这个id映射的时间
func (s *SnowFlake) GetTime(flowno int64) time.Time {
    flowtp := flowno >> (WORKER_ID_LEN + FLOW_LEN)
    utctp := flowtp + INIT_TIME
    tm := time.Unix(utctp/1000, 0)
    return tm
}

// GenerateByTime 传入一个时间，生成一个对应的snowflake id
func (s *SnowFlake) GenerateByTime(t time.Time) int64 {
    return s.generate(t)
}

// Generate 以当前时间生成一个snowflake ID
func (s *SnowFlake) Generate() int64 {
    return s.generate(time.Now())
}

// NewSnowFlake 创建snowflake对象
func NewSnowFlake() *SnowFlake {
    s := new(SnowFlake)
    s.lastTp = 0

    s.flow = 0
    return s
}

func int2Str(v int64) string {
    buff := ""
    i := 0
    for v > 0 {
        m := v % 62
        if m <= 9 {
            i++
            buff = string('0'+m) + buff
        } else if m > 9 && m <= 9+26 {
            i++
            buff = string('A'+m-10) + buff
        } else if m > 9+26 && m <= 9+26+26 {
            i++
            buff = string('a'+m-9-26-1) + buff
        }
        v = v / 62
    }
    return buff
}

func int2StrLower(v int64) string {
    buff := ""
    i := 0
    for v > 0 {
        m := v % 36
        if m <= 9 {
            i++
            buff = string('0'+m) + buff
        } else {
            i++
            buff = string('a'+m-10) + buff
        }
        v = v / 36
    }
    for len(buff) < 8 {
        buff = "0" + buff
    }
    return buff
}