type Prize struct{
    ID     int`json:"id"`
    Name   string`json:"name"`
    Weight int`json:"weight"`// 權(quán)重值
    Stock  int`json:"stock"`// 庫存
}

type LotterySystem struct{
    prizes      []Prize
    totalWeight int
    rwLock      sync.RWMutex
}

// 預(yù)計(jì)算總權(quán)重
func(ls *LotterySystem)calcTotalWeight(){
    ls.totalWeight =0
for_, prize :=range ls.prizes {
        ls.totalWeight += prize.Weight
}
}

// 抽獎(jiǎng)核心算法
func(ls *LotterySystem)Draw()(*Prize,error){
    ls.rwLock.Lock()
defer ls.rwLock.Unlock()

if ls.totalWeight <=0{
returnnil, errors.New("no available prizes")
}

// 使用crypto/rand生成安全隨機(jī)數(shù)
    randNum, err := rand.Int(rand.Reader, big.NewInt(int64(ls.totalWeight)))
if err !=nil{
returnnil, err
}
    r := randNum.Int64()

var accumulated int
for i :=range ls.prizes {
if ls.prizes[i].Stock <=0{
continue
}
        accumulated += ls.prizes[i].Weight
if r <int64(accumulated){
            ls.prizes[i].Stock--
return&ls.prizes[i],nil
}
}

returnnil, errors.New("draw failed")
}

// 二分查找優(yōu)化版本
func(ls *LotterySystem)fastDraw()(*Prize,error){
// ... 前置檢查同上

    randNum,_:= rand.Int(rand.Reader, big.NewInt(int64(ls.totalWeight)))
    r := randNum.Int64()

// 使用二分查找定位獎(jiǎng)品
    idx := sort.Search(len(ls.prizes),func(i int)bool{
return ls.prizes[i].weightAcc >=int(r)
})

if idx <len(ls.prizes)&& ls.prizes[idx].Stock >0{
        ls.prizes[idx].Stock--
return&ls.prizes[idx],nil
}
returnnil, errors.New("draw failed")
}

type ConcurrentLottery struct{
    globalLock  sync.RWMutex      // 全局配置鎖
    prizeLocks  []sync.Mutex      // 獎(jiǎng)品粒度鎖
    userLocks   sync.Map          // 用戶ID粒度鎖
}

// 用戶級(jí)別抽獎(jiǎng)
func(cl *ConcurrentLottery)UserDraw(userID string)(*Prize,error){
// 用戶粒度鎖防止重復(fù)請(qǐng)求
    userLock,_:= cl.userLocks.LoadOrStore(userID,&sync.Mutex{})
    mu := userLock.(*sync.Mutex)
    mu.Lock()
defer mu.Unlock()

// 全局讀鎖保護(hù)配置
    cl.globalLock.RLock()
defer cl.globalLock.RUnlock()

// 抽獎(jiǎng)邏輯...
}

-- redis_deny_duplicate.lua
local key = KEYS[1]-- 如 "lottery:2023:user:"..userID
local prizeID = ARGV[1]
local ttl = ARGV[2]

-- 使用SETNX實(shí)現(xiàn)原子操作
if redis.call("SETNX", key, prizeID)==1then
    redis.call("EXPIRE", key, ttl)
return1-- 成功
else
return0-- 已存在記錄
end

func(s *Server)handleLottery(c *gin.Context){
var req struct{
        UserID     string`json:"user_id" binding:"required"`
        ActivityID string`json:"activity_id" binding:"required"`
}

// 1. 參數(shù)校驗(yàn)
if err := c.ShouldBindJSON(&req); err !=nil{
        c.JSON(400, gin.H{"error": err.Error()})
return
}

// 2. 頻率限制
if!s.limiter.Allow(req.UserID){
        c.JSON(429, gin.H{"error":"too many requests"})
return
}

// 3. 執(zhí)行抽獎(jiǎng)
    prize, err := s.lotterySystem.Draw(req.UserID, req.ActivityID)
if err !=nil{
        c.JSON(500, gin.H{"error": err.Error()})
return
}

// 4. 記錄結(jié)果
    resultID := s.recordResult(req.UserID, prize)

    c.JSON(200, gin.H{
"result_id": resultID,
"prize":    prize,
})
}

funcBenchmarkLottery(b *testing.B){
// 初始化100個(gè)獎(jiǎng)品
    system :=NewLotterySystem(genPrizes(100))

    b.RunParallel(func(pb *testing.PB){
for pb.Next(){
            system.Draw("test_user")
}
})
}

// 使用對(duì)象池減少GC壓力
var prizePool = sync.Pool{
    New:func()interface{}{
returnnew(Prize)
},
}

funcgetPrize()*Prize {
    p := prizePool.Get().(*Prize)
    p.Reset()// 重置字段
return p
}

funcputPrize(p *Prize){
    prizePool.Put(p)
}

funcTestProbabilityDistribution(t *testing.T){
    system :=NewLotterySystem(testPrizes)
    results :=make(map[int]int)
    total :=1000000

for i :=0; i < total; i++{
        prize,_:= system.Draw()
        results[prize.ID]++
}

for id, count :=range results {
        got :=float64(count)/float64(total)
        want :=float64(getPrizeWeight(id))/float64(system.totalWeight)
        diff := math.Abs(got - want)
if diff >0.01{// 允許1%誤差
            t.Errorf("prize %d: got %.4f, want %.4f", id, got, want)
}
}
}

type PrizeManager struct{
    redisClient *redis.Client
}

// 使用Redis原子操作扣減庫存
func(pm *PrizeManager)DeductStock(prizeID string)(bool,error){
    script :=`
    local key = KEYS[1]
    local stock = tonumber(redis.call("GET", key))
    if stock and stock > 0 then
        return redis.call("DECR", key)
    else
        return -1
    end`

    res, err := pm.redisClient.Eval(script,[]string{"prize:"+ prizeID}).Int()
if err !=nil{
returnfalse, err
}
return res >=0,nil
}

version:'3'
services:
lottery-api:
image: lottery:1.0
ports:
-"8080:8080"
depends_on:
- redis
- mysql
environment:
- REDIS_ADDR=redis:6379
- MYSQL_DSN=mysql://user:pass@mysql:3306/lottery

redis:
image: redis:6-alpine
ports:
-"6379:6379"
volumes:
- redis_data:/data

mysql:
image: mysql:8.0
environment:
- MYSQL_ROOT_PASSWORD=secret
- MYSQL_DATABASE=lottery
volumes:
- mysql_data:/var/lib/mysql

volumes:
redis_data:
mysql_data:

apiVersion: apps/v1
kind: Deployment
metadata:
name: lottery
spec:
replicas:3
selector:
matchLabels:
app: lottery
template:
metadata:
labels:
app: lottery
spec:
containers:
-name: lottery
image: lottery:1.0
ports:
-containerPort:8080
resources:
limits:
cpu:"1"
memory:"512Mi"
readinessProbe:
httpGet:
path: /health
port:8080
initialDelaySeconds:5
periodSeconds:10
---
apiVersion: v1
kind: Service
metadata:
name: lottery
spec:
selector:
app: lottery
ports:
-protocol: TCP
port:80
targetPort:8080