Files
dygou_go/internal/seckill/score_baseline.go
T

312 lines
8.5 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 秒,便于判断基线有多旧
}
type scoreBaselineJob struct {
snapshot map[string]scoreBaselineEntry
ack chan struct{}
}
// ScoreBaselineStore 记录每个账号"上次已知的积分余额",作为抢购结束后核对的基线。
//
// 刻意不在抢购链路里取基线:账号多的时候,预热或触发时刻的任何额外请求都会挤占抢购。
// 基线只在三个时机更新——导入账号时自动查一次、用户手动查积分时、以及每次抢购核对之后
// (把最新的余额存回去,下一次抢购的基线就是上一次的终值,差值才准)。
//
// 写盘是异步的:抢购刚结束时几十个账号会同时回写基线,同步写会让抢购收尾多等
// 几百毫秒到几秒。基线只是"上一次已知的余额",晚几秒落盘不影响下一次抢购的比对,
// 所以把写盘丢给后台协程,抢购本身不等待。
type ScoreBaselineStore struct {
mu sync.RWMutex
path string
entries map[string]scoreBaselineEntry
// flushCh 承接待落盘的快照;后台协程串行写盘,避免并发写互相覆盖。
flushCh chan scoreBaselineJob
// 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 scoreBaselineJob, 8)
store.done = make(chan struct{})
go store.flushLoop()
}
return store
}
// flushLoop 串行消费待落盘快照。
//
// 只保留最新的一份快照:写盘是"整份覆盖",中间状态没有价值,
// 队列满了就丢弃旧快照(写入最新状态即可),绝不让抢购侧阻塞等待。
func (s *ScoreBaselineStore) flushLoop() {
defer close(s.done)
for job := range s.flushCh {
if job.snapshot != nil {
s.writeFile(job.snapshot)
}
if job.ack != nil {
close(job.ack)
}
}
}
// 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
}
s.enqueueLocked(scoreBaselineJob{snapshot: snapshot})
}
func (s *ScoreBaselineStore) enqueueLocked(job scoreBaselineJob) {
for {
select {
case s.flushCh <- job:
return
default:
// 队列满:丢掉最旧的一份,腾出位置放最新的。
select {
case dropped := <-s.flushCh:
if dropped.ack != nil {
close(dropped.ack)
}
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
}
if s.flushCh != nil {
ack := make(chan struct{})
s.closeMu.Lock()
if !s.closed {
s.enqueueLocked(scoreBaselineJob{ack: ack})
} else {
ack = nil
}
s.closeMu.Unlock()
if ack != nil {
<-ack
}
}
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)
}
}