Files
dygou_go/internal/seckill/score_baseline.go
T
yml2213 288109de2f 按 10-23 三机抢购日志复盘修正重试节奏与状态口径,发布0.3.8
10-23 三台机器 13 个实例抢同一次 18:00 的精英手册,把当天日志翻完发现
四个问题都指向"请求发得太猛、发得太早、结论分得太粗":

- 被限流的账号仍按 100ms 节奏猛打。单实例锁单 950~1650 次(约 20 QPS)时
  18~24 个账号被"您点击太快",而锁单仅 148 次的实例 30 个账号一次全中——
  可见"点击太快/活动火爆"是账号级封禁,继续打只会加深封禁。
- 定时器提前约 100ms 触发,想用这点提前量抵消 RTT,结果 148 次请求
  被明确拒绝:"不在时间范围内 不能兑换"。它们全部落在斗鱼估算时间
  -0.026s ~ +0.172s,也就是活动还没开闸就冲进去了。
- 积分基线写盘用 os.Rename 覆盖旧文件,Windows 上会报 Access is denied,
  三机日志里出现 281 次"积分基线写入失败",基线没落盘导致 pc-1 四个实例
  0 条核对记录,且基线为 0 时会误报"积分未见减少"。
- "已达本次活动兑换上限"被记成账号级终止失败。这其实是"该账号在本次活动
  里已经换到过了",10-23 日志里这些账号紧接着就报了"积分已扣减,兑换确认"。

- 限流改为单账号阶梯降频:新增 throttleBackoff,第 1 次等 1~2s、第 2 次
  2~3s、第 3 次 3~4s……上限 5s,区间内随机取值避免同步醒来。throttleStreak
  独立计数,非限流的失败会把它归零——只有"连续被限流"才越等越久。
  每个账号跑在自己的 goroutine 里,降频只压它自己的下一次尝试,
  不占用并发额度、不影响其它账号的节奏。
- 触发时刻改为精确命中:dynamicAdvance 返回 0,不再提前。另加兜底守卫——
  服务端回"不在时间范围内"时该次尝试不计失败、不消耗 attempts/failStreak、
  不触发降频,用 50~150ms 快速重试直到活动真正开始。结果集里的
  "失败|不在时间范围内…"同步改写成"等待活动开始",避免界面闪红。
- 积分基线改异步写盘:flushCh 队列 + 后台协程串行写,抢购收尾不再等写盘;
  新增 Flush 供需要确定落盘的场合。另按 build tag 分平台解决 Windows
  os.Rename 不能覆盖已有文件的问题(replace_file_unix/windows.go)。
- "已达兑换上限"单列:新增 outcomeLimitReached,结果集写"已抢到|"前缀,
  汇总行加"已达兑换上限=N",既不计入失败也不混进"账号终止"。
- 账号不做全局去重:同一账号可以买多个皮肤,不同实例也可以抢不同皮肤。
- 新增测试 throttle_backoff_test.go(12 个用例):降频阶梯递增、单账号级
  隔离、非限流失败重置阶梯、兑换上限不计失败且立即收手、精确命中不提前、
  活动未开始不触发降频且不记失败、Flush 同步落盘。
- 三个原有测试因降频语义变化需要调整时间尺度:新增 speedUpThrottleBackoff
  只压缩阶梯的时间尺度,不改变阶梯结构。
2026-10-24 12:27:21 +08:00

282 lines
7.9 KiB
Go

package seckill
import (
"encoding/json"
"os"
"path/filepath"
"sort"
"sync"
"time"
"douyu_go/internal/logger"
)
// scoreBaselineFileName 是积分基线文件名,和账号库放在同一个数据目录。
const scoreBaselineFileName = "scores.json"
// scoreBaselineEntry 是单个账号上一次已知的积分余额。
type scoreBaselineEntry struct {
Score int `json:"score"`
At int64 `json:"at"` // Unix 秒,便于判断基线有多旧
}
// ScoreBaselineStore 记录每个账号"上次已知的积分余额",作为抢购结束后核对的基线。
//
// 刻意不在抢购链路里取基线:账号多的时候,预热或触发时刻的任何额外请求都会挤占抢购。
// 基线只在三个时机更新——导入账号时自动查一次、用户手动查积分时、以及每次抢购核对之后
// (把最新的余额存回去,下一次抢购的基线就是上一次的终值,差值才准)。
//
// 写盘是异步的:抢购刚结束时几十个账号会同时回写基线,同步写会让抢购收尾多等
// 几百毫秒到几秒。基线只是"上一次已知的余额",晚几秒落盘不影响下一次抢购的比对,
// 所以把写盘丢给后台协程,抢购本身不等待。
type ScoreBaselineStore struct {
mu sync.RWMutex
path string
entries map[string]scoreBaselineEntry
// flushCh 承接待落盘的快照;后台协程串行写盘,避免并发写互相覆盖。
flushCh chan map[string]scoreBaselineEntry
// done 在关闭时等待后台写盘结束,保证退出前不丢数据。
done chan struct{}
// closeMu 保护 flushCh 的发送与关闭,避免"关闭后发送"导致 panic。
closeMu sync.Mutex
// closed 标记后台协程是否已关闭。
closed bool
}
// NewScoreBaselineStore 创建积分基线存储;path 为空时退化为纯内存。
func NewScoreBaselineStore(path string) *ScoreBaselineStore {
store := &ScoreBaselineStore{
path: path,
entries: make(map[string]scoreBaselineEntry),
}
if path != "" {
store.flushCh = make(chan map[string]scoreBaselineEntry, 8)
store.done = make(chan struct{})
go store.flushLoop()
}
return store
}
// flushLoop 串行消费待落盘快照。
//
// 只保留最新的一份快照:写盘是"整份覆盖",中间状态没有价值,
// 队列满了就丢弃旧快照(写入最新状态即可),绝不让抢购侧阻塞等待。
func (s *ScoreBaselineStore) flushLoop() {
defer close(s.done)
for snapshot := range s.flushCh {
s.writeFile(snapshot)
}
}
// Close 关闭后台写盘协程,并等待队列里的数据落盘完成。
func (s *ScoreBaselineStore) Close() {
if s == nil || s.flushCh == nil {
return
}
s.closeMu.Lock()
if !s.closed {
s.closed = true
close(s.flushCh)
}
s.closeMu.Unlock()
<-s.done
// 队列里的旧快照可能已经过时,最后再按当前状态同步写一次,
// 确保退出时磁盘上的就是内存里的最终值。
s.Flush()
}
// enqueue 把快照交给后台写盘;队列满时丢弃旧快照并保留最新一份。
//
// 关闭后调用是安全的(直接丢弃):退出流程里 Close 与最后一次回写可能并发。
func (s *ScoreBaselineStore) enqueue(snapshot map[string]scoreBaselineEntry) {
if s == nil || s.flushCh == nil || len(snapshot) == 0 {
return
}
s.closeMu.Lock()
defer s.closeMu.Unlock()
if s.closed {
return
}
for {
select {
case s.flushCh <- snapshot:
return
default:
// 队列满:丢掉最旧的一份,腾出位置放最新的。
select {
case <-s.flushCh:
default:
}
}
}
}
// Load 从磁盘读取基线。文件缺失或损坏都不算错误,只是没有基线可用。
func (s *ScoreBaselineStore) Load() {
if s == nil || s.path == "" {
return
}
data, err := os.ReadFile(s.path)
if err != nil {
return
}
loaded := make(map[string]scoreBaselineEntry)
if err := json.Unmarshal(data, &loaded); err != nil {
logger.LogEvent("核对", "warn", "积分基线文件解析失败,将重新累积: %v", err)
return
}
s.mu.Lock()
s.entries = loaded
s.mu.Unlock()
}
// Get 返回账号上一次已知的积分余额。
func (s *ScoreBaselineStore) Get(accountName string) (int, bool, time.Time) {
if s == nil {
return 0, false, time.Time{}
}
s.mu.RLock()
entry, ok := s.entries[accountName]
s.mu.RUnlock()
if !ok {
return 0, false, time.Time{}
}
return entry.Score, true, time.Unix(entry.At, 0)
}
// Set 记录一个账号的最新积分余额,并落盘。
func (s *ScoreBaselineStore) Set(accountName string, score int) {
s.SetMany(map[string]int{accountName: score})
}
// SetMany 批量记录并落盘(一次写盘,避免每个账号都写一次文件)。
func (s *ScoreBaselineStore) SetMany(values map[string]int) {
if s == nil || len(values) == 0 {
return
}
now := time.Now().Unix()
s.mu.Lock()
for name, score := range values {
s.entries[name] = scoreBaselineEntry{Score: score, At: now}
}
snapshot := make(map[string]scoreBaselineEntry, len(s.entries))
for name, entry := range s.entries {
snapshot[name] = entry
}
s.mu.Unlock()
s.flush(snapshot)
}
// Forget 删除已不存在账号的基线。
func (s *ScoreBaselineStore) Forget(accountNames []string) {
if s == nil || len(accountNames) == 0 {
return
}
s.mu.Lock()
for _, name := range accountNames {
delete(s.entries, name)
}
snapshot := make(map[string]scoreBaselineEntry, len(s.entries))
for name, entry := range s.entries {
snapshot[name] = entry
}
s.mu.Unlock()
s.flush(snapshot)
}
// Snapshot 返回全部账号的最新积分余额副本。
func (s *ScoreBaselineStore) Snapshot() map[string]int {
if s == nil {
return nil
}
s.mu.RLock()
defer s.mu.RUnlock()
out := make(map[string]int, len(s.entries))
for name, entry := range s.entries {
out[name] = entry.Score
}
return out
}
// Names 返回已记录基线的账号名(按字典序),便于测试与排查。
func (s *ScoreBaselineStore) Names() []string {
if s == nil {
return nil
}
s.mu.RLock()
out := make([]string, 0, len(s.entries))
for name := range s.entries {
out = append(out, name)
}
s.mu.RUnlock()
sort.Strings(out)
return out
}
// Flush 把当前基线同步落盘。
//
// 正常流程不需要它:写盘已经是异步的,抢购不会等。
// 它用于"必须确保落盘"的场合:程序退出前、以及需要立刻读到文件的场景。
func (s *ScoreBaselineStore) Flush() {
if s == nil || s.path == "" {
return
}
s.mu.RLock()
snapshot := make(map[string]scoreBaselineEntry, len(s.entries))
for name, entry := range s.entries {
snapshot[name] = entry
}
s.mu.RUnlock()
if len(snapshot) == 0 {
return
}
s.writeFile(snapshot)
}
// flush 把快照交给后台写盘,不阻塞调用方(抢购链路不能被写盘拖慢)。
func (s *ScoreBaselineStore) flush(snapshot map[string]scoreBaselineEntry) {
if s == nil || s.path == "" {
return
}
s.enqueue(snapshot)
}
// writeFile 原子写盘:先写临时文件再改名,避免半写入损坏。
//
// Windows 上 os.Rename 不能覆盖已存在的文件(会报 Access is denied),
// 2026-10-23 的三机日志里因此出现了 281 次"积分基线写入失败"——
// 多实例同时写同一个 scores.json 时尤其明显。Posix 上 Rename 是覆盖语义,
// 直接用即可;Windows 上先删旧文件再改名。
func (s *ScoreBaselineStore) writeFile(snapshot map[string]scoreBaselineEntry) {
if s == nil || s.path == "" {
return
}
data, err := json.MarshalIndent(snapshot, "", " ")
if err != nil {
return
}
dir := filepath.Dir(s.path)
if dir != "" && dir != "." {
if err := os.MkdirAll(dir, 0700); err != nil {
return
}
}
tmp, err := os.CreateTemp(dir, "."+filepath.Base(s.path)+".*.tmp")
if err != nil {
return
}
tmpPath := tmp.Name()
defer func() { _ = os.Remove(tmpPath) }()
if _, err := tmp.Write(data); err != nil {
_ = tmp.Close()
return
}
if err := tmp.Close(); err != nil {
return
}
if err := replaceFile(tmpPath, s.path); err != nil {
logger.LogEvent("核对", "warn", "积分基线写入失败: %v", err)
}
}