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 只压缩阶梯的时间尺度,不改变阶梯结构。
282 lines
7.9 KiB
Go
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)
|
|
}
|
|
}
|