在go语言种实现微秒生成服务示例代码

Go  /  管理员 发布于 6个月前   171

微秒生成服务使用场景：比如实现一个聊天室，拉取历史消息时，排序采用微秒时间进行，

得保证每条消息的微秒值不一样的功能。

代码示例：

package main
import (
    "encoding/json"
    "flag"
    "github.com/valyala/fasthttp"
    "log"
    "sync"
    "sync/atomic"
    "time"
)
var collection *Collection
func init() {
    collection = NewCollection()
}
func main() {
    addr := flag.String("addr", "0.0.0.0:7788", "listen host")
    flag.Parse()
    s := &fasthttp.Server{
        Handler: requestHandler,
        Logger:  NullLogger{},
    }
    log.Println("listen http" + "://" + *addr)
    err := s.ListenAndServe(*addr)
    if err != nil {
        log.Fatalln(err)
    }
}
func requestHandler(ctx *fasthttp.RequestCtx) {
    //业务key
    key := string(ctx.QueryArgs().Peek("key"))
    //需要得到的微秒个数
    incr := int64(ctx.QueryArgs().GetUintOrZero("incr"))
    var ret Ret
    if key == "" || incr == 0 {
        ret = Ret{Code: 1, Message: "invalid argument", Data: 0}
    } else {
        //客户端拿到data后循环incr次，每次自增1，即可展开得到所有的微秒
        ret = Ret{Code: 0, Message: "success", Data: collection.Get(key).Get(incr) - incr}
    }
    ctx.SetContentType("application/json; charset=UTF-8")
    _, _ = ctx.Write(ret.Encode())
}
// NullLogger 空日志
type NullLogger struct {
}
func (r NullLogger) Printf(string, ...any) {
}
// Ret 返回结构
type Ret struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Data    int64  `json:"data"`
}
func (r Ret) Encode() []byte {
    ret, _ := json.Marshal(r)
    return ret
}
// Micro 微秒对象
type Micro struct {
    incr *int64
}
func NewMicro() *Micro {
    var incr int64
    micro := &Micro{
        incr: &incr,
    }
    micro.Reset(time.Now())
    return micro
}
func (r *Micro) Get(num int64) int64 {
    return atomic.AddInt64(r.incr, num)
}
func (r *Micro) Reset(t time.Time) {
    atomic.StoreInt64(r.incr, t.Unix()*1000000)
}
// Collection 所有微秒服务的集合
type Collection struct {
    data  map[string]*Micro
    mutex *sync.RWMutex
}
func NewCollection() *Collection {
    c := &Collection{data: map[string]*Micro{}, mutex: &sync.RWMutex{}}
    //每隔1秒刷新集合中的所有变量的值
    go func(collection *Collection) {
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()
        for {
            t := <-ticker.C
            c.Reset(t)
        }
    }(c)
    return c
}
func (r *Collection) Get(key string) *Micro {
    r.mutex.RLock()
    micro, ok := r.data[key]
    r.mutex.RUnlock()
    if ok {
        return micro
    }
    r.mutex.Lock()
    micro, ok = r.data[key]
    if ok {
        r.mutex.Unlock()
        return micro
    }
    micro = NewMicro()
    r.data[key] = micro
    r.mutex.Unlock()
    return micro
}
func (r *Collection) Reset(t time.Time) {
    r.mutex.RLock()
    for _, v := range r.data {
        v.Reset(t)
    }
    r.mutex.RUnlock()
}

有兴趣的可以自行测试。