需求描述

• 支持配置多个奖品及对应权重
  
• 保证抽奖结果符合权重概率分布
  
• 防止重复中奖
  
• 提供抽奖结果验证接口
  

完整实现代码

1. package main
   
2. 
   
3. import (
   
4.     "crypto/rand"
   
5.     "encoding/json"
   
6.     "fmt"
   
7.     "math/big"
   
8.     "net/http"
   
9.     "sync"
   
10. )
    
11. 
    
12. // 奖品配置
    
13. type Prize struct {
    
14.     ID     int    `json:"id"`
    
15.     Name   string `json:"name"`
    
16.     Weight int    `json:"weight"` // 权重值（非百分比）
    
17. }
    
18. 
    
19. // 抽奖系统
    
20. type LotterySystem struct {
    
21.     prizes       []Prize
    
22.     totalWeight  int
    
23.     issuedPrizes map[int]bool
    
24.     mu           sync.Mutex
    
25. }
    
26. 
    
27. // 初始化抽奖系统
    
28. func NewLotterySystem(prizes []Prize) *LotterySystem {
    
29.     total := 0
    
30.     for _, p := range prizes {
    
31.         total += p.Weight
    
32.     }
    
33.     return &LotterySystem{
    
34.         prizes:       prizes,
    
35.         totalWeight:  total,
    
36.         issuedPrizes: make(map[int]bool),
    
37.     }
    
38. }
    
39. 
    
40. // 安全随机数生成
    
41. func secureRandom(max int) (int, error) {
    
42.     n, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
    
43.     if err != nil {
    
44.         return 0, err
    
45.     }
    
46.     return int(n.Int64()), nil
    
47. }
    
48. 
    
49. // 执行抽奖
    
50. func (ls *LotterySystem) Draw() (*Prize, error) {
    
51.     ls.mu.Lock()
    
52.     defer ls.mu.Unlock()
    
53. 
    
54.     if ls.totalWeight == 0 {
    
55.         return nil, fmt.Errorf("no available prizes")
    
56.     }
    
57. 
    
58.     // 生成随机数
    
59.     randomNum, err := secureRandom(ls.totalWeight)
    
60.     if err != nil {
    
61.         return nil, err
    
62.     }
    
63. 
    
64.     // 权重选择
    
65.     current := 0
    
66.     for _, p := range ls.prizes {
    
67.         current += p.Weight
    
68.         if randomNum < current {
    
69.             if ls.issuedPrizes[p.ID] {
    
70.                 continue // 已发放的奖品跳过
    
71.             }
    
72.             ls.issuedPrizes[p.ID] = true
    
73.             return &p, nil
    
74.         }
    
75.     }
    
76. 
    
77.     return nil, fmt.Errorf("draw failed")
    
78. }
    
79. 
    
80. // HTTP服务
    
81. func main() {
    
82.     // 初始化奖品池
    
83.     prizes := []Prize{
    
84.         {ID: 1, Name: "一等奖", Weight: 1},
    
85.         {ID: 2, Name: "二等奖", Weight: 5},
    
86.         {ID: 3, Name: "三等奖", Weight: 20},
    
87.         {ID: 4, Name: "参与奖", Weight: 74},
    
88.     }
    
89. 
    
90.     lottery := NewLotterySystem(prizes)
    
91. 
    
92.     http.HandleFunc("/draw", func(w http.ResponseWriter, r *http.Request) {
    
93.         prize, err := lottery.Draw()
    
94.         if err != nil {
    
95.             http.Error(w, err.Error(), http.StatusInternalServerError)
    
96.             return
    
97.         }
    
98. 
    
99.         w.Header().Set("Content-Type", "application/json")
    
100.         json.NewEncoder(w).Encode(prize)
     
101.     })
     
102. 
     
103.     fmt.Println("抽奖服务已启动，监听端口 8080")
     
104.     http.ListenAndServe(":8080", nil)
     
105. }

复制代码

核心功能说明

权重算法：

1. // 权重选择逻辑
   
2. current := 0
   
3. for _, p := range ls.prizes {
   
4.     current += p.Weight
   
5.     if randomNum < current {
   
6.         return &p
   
7.     }
   
8. }

复制代码

• 使用累计权重区间算法
  
• 保证概率分布准确性
  

安全随机数：

1. // 使用crypto/rand生成安全随机数
   
2. func secureRandom(max int) (int, error) {
   
3.     n, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
   
4.     // ...
   
5. }

复制代码

• 避免使用math/rand的可预测性
  
• 满足安全抽奖需求
  

并发控制：

1. var mu sync.Mutex
   
2. 
   
3. func (ls *LotterySystem) Draw() {
   
4.     ls.mu.Lock()
   
5.     defer ls.mu.Unlock()
   
6.     // ...
   
7. }

复制代码

• 使用互斥锁保证线程安全
  
• 防止并发抽奖导致的数据竞争
  

防重复机制：

1. issuedPrizes map[int]bool

复制代码

• 使用内存映射记录已发放奖品
  
• 生产环境可替换为Redis等持久化存储
  

扩展功能建议

概率可视化验证：

1. // 添加测试端点验证概率分布
   
2. http.HandleFunc("/test", func(w http.ResponseWriter, r *http.Request) {
   
3.     results := make(map[int]int)
   
4.     for i := 0; i < 10000; i++ {
   
5.         tempLottery := NewLotterySystem(prizes)
   
6.         prize, _ := tempLottery.Draw()
   
7.         results[prize.ID]++
   
8.     }
   
9.     json.NewEncoder(w).Encode(results)
   
10. })

复制代码

分布式锁扩展：

1. // 使用Redis分布式锁
   
2. func (ls *LotterySystem) DistributedDraw() {
   
3.     lock := redis.NewLock("lottery_lock")
   
4.     err := lock.Lock()
   
5.     // ...抽奖逻辑...
   
6.     lock.Unlock()
   
7. }

复制代码

奖品库存管理：

1. type Prize struct {
   
2.     // ...
   
3.     Stock     int // 新增库存字段
   
4. }
   
5. func (ls *LotterySystem) Draw() {
   
6.     // 检查库存
   
7.     if p.Stock <= 0 {
   
8.         continue
   
9.     }
   
10.     // 扣减库存
    
11.     p.Stock--
    
12. }

复制代码

运行测试

启动服务：

1. go run main.go

复制代码

测试抽奖：

1. curl http://localhost:8080/draw
   
2. # 示例返回：{"id":3,"name":"三等奖","weight":20}

复制代码

概率验证测试：

1. curl http://localhost:8080/test
   
2. # 返回万次抽奖结果分布

复制代码

关键优化点

性能优化：

• 使用预计算总权重值
  
• 内存级锁粒度控制
  
• 对象池复用
  

安全增强：

• JWT用户身份验证
  
• 抽奖频率限制
  
• 敏感操作日志
  

业务扩展：

• 支持不同抽奖活动
  
• 奖品有效期管理
  
• 中奖名单公示
  

到此这篇关于Go语言实现权重抽奖系统的项目实践的文章就介绍到这了,更多相关Go语言 权重抽奖系统内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：互联网
免责声明：如果侵犯了您的权益，请联系站长（1277306191@qq.com），我们会及时删除侵权内容，谢谢合作！