Files
dygou_go/internal/seckill/scheduler.go
T
yml2213 bc366fd6b9 feat(proxy): 支持多实例独立代理与短效API动态提取
- 实例配置独立:支持为每个实例单独配置 http/https/socks5 代理,避免单机多开挤兑触发斗鱼出口 IP 限流
- 动态 API 提取:原生支持星空代理等平台的 API 提取(兼容 JSON/文本格式),提供前端一键提取填入与连通性/延迟测速
- 定时前自动拉取:针对 3 分钟短效代理,支持在开抢前 15 秒自动提取并绑定最新 IP,并在预热前完成热连接与时间复校
- 修复复校竞态:将 resyncBeforeTrigger 从 3s 提升至 8s,确保三轮采样在开抢前顺利落盘,消除时钟漂移
- 验证方式:通过 go test ./... 全量测试与前端 vue-tsc/vite 编译,实测通过星空代理 API 解析测试用例
2026-10-24 19:26:16 +08:00

1464 lines
50 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package seckill
import (
"fmt"
"math/rand"
"path/filepath"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/golang/freetype/truetype"
"douyu_go/internal/client"
"douyu_go/internal/constants"
"douyu_go/internal/image"
"douyu_go/internal/logger"
"douyu_go/internal/types"
"douyu_go/internal/utils"
)
const (
warmupBeforeTrigger = 2 * time.Second
warmupMaxAge = 30 * time.Second
qualifiedMaxAge = 30 * time.Second
timeCalibrateRounds = 3
timeCalibrateWait = 1200 * time.Millisecond
resyncBeforeTrigger = 8 * time.Second
proxyFetchBeforeTrigger = 15 * time.Second
calibrationHistorySize = 3
maxCooldownCount = 5
xiaodianDefaultDelay = 500 * time.Millisecond
)
// seckillMaxDuration 是手册类活动的抢购窗口:超过后不再发起新的锁单。
// 声明为变量是为了让测试能缩短窗口。
var seckillMaxDuration = 75 * time.Second
type roundOutcome struct {
successAccounts map[string]bool
stoppedAccounts map[string]string
stoppedProducts map[string]string
cooldownAccounts map[string]time.Time
results map[string]types.ExchangeResult
attempts int
}
type runSettings struct {
concurrency int
attempts int
retryStages []types.RetryStage
seckillMode types.SeckillMode
}
// Scheduler 抢购调度器。
// 具体职责拆分到同包文件:attempt.go(兑换执行)、warmup.go(预热)、
// schedule_timer.go(定时抢购)、account_store.go(账号管理)。
type Scheduler struct {
clientMu sync.RWMutex
client *client.DouyuClient
paths types.AppPaths
font *truetype.Font
successImages *image.SuccessImageSaver
settingsMu sync.RWMutex
concurrency int // 抢购并发数
attempts int // 单号重试次数
retryStages []types.RetryStage // 重试间隔阶段配置
seckillMode types.SeckillMode // 抢购模式
accounts *AccountStore
scoreBaselines *ScoreBaselineStore
resultsMu sync.RWMutex
results map[string]string
reportMu sync.RWMutex
latestXiaodianReport *types.XiaodianRunReport
runMu sync.Mutex
running bool
stopRun chan struct{}
stopRequested bool
stateMu sync.RWMutex
onStateChange func(string)
// pendingClient 保存运行中收到的客户端更新,当前任务结束后自动应用。
pendingClient *client.DouyuClient
scheduleMu sync.Mutex
schedule *time.Timer
warmupSchedule *time.Timer
resyncSchedule *time.Timer
proxyFetchSchedule *time.Timer
warmupGen int64
proxyMu sync.RWMutex
proxyEnabled bool
proxyURL string
proxyAPI string
autoFetchProxyOnSchedule bool
warmupsMu sync.RWMutex
warmups map[string]types.WarmupData
warmupRunMu sync.Mutex
attemptCacheMu sync.RWMutex
attemptCache map[string]*types.AttemptCache // 激进模式缓存
productsMu sync.RWMutex
products map[string]types.Product
calibrationMu sync.Mutex
calibrationOffsets []time.Duration // 最近N次校准偏移,用于中位数平滑
}
// SetStateChangeCallback 设置运行状态变化回调。
func (s *Scheduler) SetStateChangeCallback(cb func(string)) {
s.stateMu.Lock()
s.onStateChange = cb
s.stateMu.Unlock()
}
func (s *Scheduler) emitState(state string) {
s.stateMu.RLock()
cb := s.onStateChange
s.stateMu.RUnlock()
if cb != nil {
cb(state)
}
}
// New 创建抢购调度器。
func New(cli *client.DouyuClient, paths types.AppPaths, font *truetype.Font, concurrency, attempts int, retryStages []types.RetryStage, seckillMode types.SeckillMode) *Scheduler {
if concurrency <= 0 {
concurrency = constants.DefaultConcurrency
}
if attempts <= 0 {
attempts = constants.DefaultAttempts
}
scheduler := &Scheduler{
client: cli,
paths: paths,
font: font,
accounts: NewAccountStore(paths.AccountFile, paths.LegacyAccountFile),
scoreBaselines: NewScoreBaselineStore(scoreBaselinePath(paths.AccountFile)),
successImages: image.NewSuccessImageSaver(
font,
paths.SuccessDir,
1,
256,
),
concurrency: concurrency,
attempts: attempts,
retryStages: cloneRetryStages(retryStages),
seckillMode: normalizeSeckillMode(seckillMode),
results: make(map[string]string),
attemptCache: make(map[string]*types.AttemptCache),
products: make(map[string]types.Product),
calibrationOffsets: make([]time.Duration, 0, calibrationHistorySize),
}
scheduler.scoreBaselines.Load()
scheduler.loadLatestXiaodianReport()
return scheduler
}
// Close 关闭调度器的后台资源。
func (s *Scheduler) Close() {
if s.successImages != nil {
s.successImages.Close()
}
// 基线写盘是异步的:退出前等它把队列里的数据落完,避免丢最后一次基线。
if s.scoreBaselines != nil {
s.scoreBaselines.Close()
}
}
// clientSnapshot 返回当前 client 的指针快照(读锁保护,用于执行期间持有一个稳定引用)。
func (s *Scheduler) clientSnapshot() *client.DouyuClient {
s.clientMu.RLock()
defer s.clientMu.RUnlock()
return s.client
}
// UpdateClient 热替换底层 HTTP 客户端(用于活动切换)。
// 若有抢购任务正在运行则暂存新客户端,当前任务结束后自动应用,并返回 false。
func (s *Scheduler) UpdateClient(newClient *client.DouyuClient) bool {
s.runMu.Lock()
if s.running {
if s.pendingClient != nil && s.pendingClient.HTTPClient != nil {
s.pendingClient.HTTPClient.CloseIdleConnections()
}
s.pendingClient = newClient
s.runMu.Unlock()
return false
}
s.runMu.Unlock()
s.replaceClient(newClient)
return true
}
func (s *Scheduler) replaceClient(newClient *client.DouyuClient) {
s.clientMu.Lock()
defer s.clientMu.Unlock()
old := s.client
s.client = newClient
if old != nil && old.HTTPClient != nil {
old.HTTPClient.CloseIdleConnections()
}
}
// UpdateProducts 更新商品缓存,抢购成功图片会优先使用中文商品名。
func (s *Scheduler) UpdateProducts(products []types.Product) {
next := make(map[string]types.Product, len(products))
for _, product := range products {
if product.CommodityID == "" {
continue
}
if product.CommodityName == "" {
product.CommodityName = product.CommodityID
}
next[product.CommodityID] = product
}
s.productsMu.Lock()
s.products = next
s.productsMu.Unlock()
}
// UpdateSettings 运行时更新并发数、重试次数、重试间隔和抢购模式。
func (s *Scheduler) UpdateSettings(concurrency, attempts int, retryStages []types.RetryStage, seckillMode types.SeckillMode) {
s.settingsMu.Lock()
defer s.settingsMu.Unlock()
if concurrency > 0 {
s.concurrency = concurrency
}
if attempts > 0 {
s.attempts = attempts
}
if len(retryStages) > 0 {
s.retryStages = cloneRetryStages(retryStages)
}
s.seckillMode = normalizeSeckillMode(seckillMode)
}
// UpdateProxySettings 运行时更新代理配置。
func (s *Scheduler) UpdateProxySettings(enabled bool, proxyURL, proxyAPI string, autoFetch bool) {
s.proxyMu.Lock()
defer s.proxyMu.Unlock()
s.proxyEnabled = enabled
s.proxyURL = proxyURL
s.proxyAPI = proxyAPI
s.autoFetchProxyOnSchedule = autoFetch
}
func (s *Scheduler) settingsSnapshot() runSettings {
s.settingsMu.RLock()
settings := runSettings{
concurrency: s.concurrency,
attempts: s.attempts,
retryStages: cloneRetryStages(s.retryStages),
seckillMode: normalizeSeckillMode(s.seckillMode),
}
s.settingsMu.RUnlock()
if settings.concurrency <= 0 {
settings.concurrency = constants.DefaultConcurrency
}
if settings.attempts <= 0 {
settings.attempts = constants.DefaultAttempts
}
return settings
}
func cloneRetryStages(stages []types.RetryStage) []types.RetryStage {
if len(stages) == 0 {
return nil
}
out := make([]types.RetryStage, len(stages))
copy(out, stages)
return out
}
func normalizeSeckillMode(mode types.SeckillMode) types.SeckillMode {
switch mode {
case types.SeckillModeNormal, types.SeckillModeAggressive:
return mode
default:
return types.SeckillModeAggressive
}
}
// ==================== 账号转发(AccountStore) ====================
// LoadAccounts 从应用内部账号库加载账号。
func (s *Scheduler) LoadAccounts() {
s.accounts.Load()
}
// AccountCount 返回当前账号数。
func (s *Scheduler) AccountCount() int {
return s.accounts.Count()
}
// AccountFilePath 返回内部账号库路径。
func (s *Scheduler) AccountFilePath() string {
return s.accounts.FilePath()
}
// AccountSnapshot 复制一份账号列表。
func (s *Scheduler) AccountSnapshot() []types.Account {
return s.accounts.Snapshot()
}
// AccountCookieByName 按账号名查找 Cookie。
func (s *Scheduler) AccountCookieByName(name string) (string, bool) {
return s.accounts.CookieByName(name)
}
// ==================== 结果管理 ====================
// Results 返回当前抢购结果快照。
func (s *Scheduler) Results() map[string]string {
s.resultsMu.RLock()
defer s.resultsMu.RUnlock()
out := make(map[string]string, len(s.results))
for k, v := range s.results {
out[k] = v
}
return out
}
// ClearResults 清空抢购结果。
func (s *Scheduler) ClearResults() {
s.resultsMu.Lock()
defer s.resultsMu.Unlock()
s.results = make(map[string]string)
}
func (s *Scheduler) setResult(key, value string) {
s.resultsMu.Lock()
defer s.resultsMu.Unlock()
s.results[key] = value
}
// ==================== 运行控制 ====================
// TryStartRun 尝试开始抢购,返回 false 表示已有任务在运行。
func (s *Scheduler) TryStartRun() bool {
s.runMu.Lock()
if s.running {
s.runMu.Unlock()
return false
}
s.running = true
s.stopRequested = false
s.stopRun = make(chan struct{})
s.runMu.Unlock()
s.emitState("running")
return true
}
func (s *Scheduler) finishRun() {
s.runMu.Lock()
s.running = false
s.stopRequested = false
s.stopRun = nil
pendingClient := s.pendingClient
s.pendingClient = nil
s.runMu.Unlock()
if pendingClient != nil {
s.replaceClient(pendingClient)
logger.LogEvent("配置", "success", "抢购任务结束,已应用等待中的客户端配置")
}
s.emitState("idle")
}
// StopRun 请求停止当前正在执行的抢购任务。
func (s *Scheduler) StopRun() bool {
s.runMu.Lock()
if !s.running || s.stopRequested || s.stopRun == nil {
s.runMu.Unlock()
return false
}
s.stopRequested = true
close(s.stopRun)
s.runMu.Unlock()
s.emitState("stopping")
return true
}
// IsRunning 返回当前是否有抢购任务正在执行。
func (s *Scheduler) IsRunning() bool {
s.runMu.Lock()
defer s.runMu.Unlock()
return s.running
}
func (s *Scheduler) stopRunChan() <-chan struct{} {
s.runMu.Lock()
defer s.runMu.Unlock()
return s.stopRun
}
func (s *Scheduler) runStopped() bool {
s.runMu.Lock()
defer s.runMu.Unlock()
return s.stopRequested
}
func (s *Scheduler) interruptibleSleep(d time.Duration) bool {
if d <= 0 {
return s.runStopped()
}
stop := s.stopRunChan()
if stop == nil {
time.Sleep(d)
return false
}
timer := time.NewTimer(d)
defer timer.Stop()
select {
case <-timer.C:
return false
case <-stop:
return true
}
}
// RunNow 立即执行手册类活动的抢购任务(精英手册锁单支付 / 电竞手册直接兑换)。
//
// 每个账号在自己的 goroutine 中独立重试,互不阻塞。早期版本用"轮次 + wg.Wait"
// 把所有账号绑在一起:3 个中签账号卡在 60 秒支付退避时,另外 31 个账号白白空转
// 39 秒(2026-10-03 日志实测),还出现过"某一轮只跑了 1 个账号、其余 33 个整轮
// 没被尝试"的退化。
//
// 窗口硬约束:到 seckillMaxDuration 后不再发起新的锁单;已经锁单成功的账号
// 仍会把支付做完(支付阶梯只受停止指令和锁单过期约束,放弃等于白锁)。
func (s *Scheduler) RunNow(accountProducts map[string]string) {
defer s.finishRun()
s.ClearResults()
settings := s.settingsSnapshot()
tasks := s.buildTasks(accountProducts)
if len(tasks) == 0 {
logger.LogEvent("抢购", "warn", "没有可执行的抢购任务")
return
}
start := time.Now()
deadline := start.Add(seckillMaxDuration)
ctl := newRunControl(s, start, deadline, settings.concurrency, len(tasks))
s.clearAttemptCache()
if settings.seckillMode == types.SeckillModeAggressive {
s.initCacheFromWarmup(tasks)
}
logger.LogEvent("抢购", "info", "开始抢购: %d 个账号,窗口=%v,截止=%s",
len(tasks), seckillMaxDuration, deadline.In(constants.CST).Format("15:04:05.000"))
for _, target := range productTargets(tasks) {
logger.LogEvent("抢购", "info", "抢购目标: %s", target)
}
// 逐条网络日志已降为 debug 级,这里开始统计每类接口的调用情况,
// 任务结束时输出一行聚合结果。
if cli := s.clientSnapshot(); cli != nil {
cli.ResetRequestStats()
}
outcomes := make([]accountOutcome, len(tasks))
var wg sync.WaitGroup
for i, task := range tasks {
wg.Add(1)
go func(index int, task types.ExchangeAttempt) {
defer wg.Done()
outcomes[index] = s.runAccountLoop(task, settings, ctl)
}(i, task)
}
wg.Wait()
s.logRunSummary(outcomes, ctl, time.Since(start))
// 先核对积分(会产生"积分余额"请求,一并计入后面的接口统计)。
s.verifyRunResults(outcomes, ctl, s.clientSnapshot())
s.logNetworkSummary(s.clientSnapshot())
}
// verifyRunResults 抢购结束后对成功账号核对积分余额。
//
// 兑换成功会扣积分,所以"余额确实少了多少"是一个独立于接口返回的确认证据:
// 2026-09-30 就出现过订单实际已支付、程序却报成失败的情况,只看接口返回不够。
// 核对在任务结束之后进行,不影响抢购本身;单个账号查询失败只记警告,
// 不改变"抢到"这个结论。
func (s *Scheduler) verifyRunResults(outcomes []accountOutcome, ctl *runControl, cli *client.DouyuClient) {
if cli == nil || cli.Activity.ScoreURL == "" {
return
}
successes := make([]accountOutcome, 0, len(outcomes))
for _, out := range outcomes {
if out.kind == outcomeSuccess {
successes = append(successes, out)
}
}
if len(successes) == 0 {
return
}
logger.LogEvent("核对", "info", "开始核对积分余额: %d 个成功账号", len(successes))
var mu sync.Mutex
confirmed := 0
var wg sync.WaitGroup
for _, out := range successes {
wg.Add(1)
go func(out accountOutcome) {
defer wg.Done()
cookie, ok := s.AccountCookieByName(out.account)
if !ok || cookie == "" {
logger.LogAccountEvent("核对", "warn", out.account, "积分核对跳过: 账号=%s 没有可用 Cookie", out.account)
return
}
if ctl != nil {
if !ctl.enter() {
return
}
defer ctl.leave()
}
score, err := cli.Score(cookie)
if err != nil {
logger.LogAccountEvent("核对", "warn", out.account, "积分核对失败: 账号=%s err=%v", out.account, err)
return
}
before, hasBefore, baselineAt := s.ScoreBaseline(out.account)
// 无论能否比对,都把最新余额存回基线:下一次抢购的"抢购前"就是这一次的终值。
s.RecordScoreBaseline(out.account, score)
if !hasBefore {
logger.LogAccountEvent("核对", "info", out.account,
"抢购后积分余额: 账号=%s 余额=%d(该账号还没有基线,本次先记录,下次抢购即可比对)", out.account, score)
return
}
if score >= before {
logger.LogAccountEvent("核对", "warn", out.account,
"积分未见减少,请核实兑换记录: 账号=%s 抢购前=%d 抢购后=%d 基线时间=%s",
out.account, before, score, baselineAt.In(constants.CST).Format("01-02 15:04:05"))
return
}
mu.Lock()
confirmed++
mu.Unlock()
logger.LogAccountEvent("核对", "success", out.account,
"积分已扣减,兑换确认: 账号=%s 抢购前=%d 抢购后=%d 扣减=%d", out.account, before, score, before-score)
// 把扣分结果附到结果集,账号表里也能直接看到确认信息。
key := resultKey(types.ExchangeAttempt{Account: types.Account{Name: out.account}})
if current := s.Results()[key]; current != "" {
s.setResult(key, fmt.Sprintf("%s|积分-%d", current, before-score))
}
}(out)
}
wg.Wait()
logger.LogEvent("核对", "info", "积分核对完成: %d/%d 个账号确认扣分", confirmed, len(successes))
}
// ScoreBaseline 返回该账号上次已知的积分余额及其记录时间。
func (s *Scheduler) ScoreBaseline(accountName string) (int, bool, time.Time) {
if s.scoreBaselines == nil {
return 0, false, time.Time{}
}
return s.scoreBaselines.Get(accountName)
}
// ScoreBaselines 返回各账号最新一次已记录的积分余额(字符串形式,供界面展示)。
func (s *Scheduler) ScoreBaselines() map[string]string {
if s.scoreBaselines == nil {
return map[string]string{}
}
snapshot := s.scoreBaselines.Snapshot()
out := make(map[string]string, len(snapshot))
for name, score := range snapshot {
out[name] = strconv.Itoa(score)
}
return out
}
// RecordScoreBaseline 记录账号的最新积分余额(落盘)。
func (s *Scheduler) RecordScoreBaseline(accountName string, score int) {
if s.scoreBaselines != nil {
s.scoreBaselines.Set(accountName, score)
}
}
// ForgetScoreBaselines 删除已移除账号的基线。
func (s *Scheduler) ForgetScoreBaselines(accountNames []string) {
if s.scoreBaselines != nil {
s.scoreBaselines.Forget(accountNames)
}
}
// FetchScoreBaselines 并发查询并记录这批账号的积分基线。
//
// 只在"添加账号"这类抢购之外的操作里调用:账号多的时候,
// 抢购链路(预热或触发时刻)绝不能承担这批额外请求。
func (s *Scheduler) FetchScoreBaselines(accounts []types.Account) {
cli := s.clientSnapshot()
if cli == nil || cli.Activity.ScoreURL == "" || len(accounts) == 0 {
return
}
if s.IsRunning() {
logger.LogEvent("账号", "warn", "抢购进行中,跳过 %d 个账号的积分基线查询(可稍后手动查询积分)", len(accounts))
return
}
settings := s.settingsSnapshot()
limit := make(chan struct{}, settings.concurrency)
var (
wg sync.WaitGroup
mu sync.Mutex
collected = make(map[string]int, len(accounts))
)
for _, account := range accounts {
if account.Cookie == "" {
continue
}
wg.Add(1)
go func(account types.Account) {
defer wg.Done()
limit <- struct{}{}
defer func() { <-limit }()
score, err := cli.Score(account.Cookie)
if err != nil {
logger.LogAccountEvent("账号", "warn", account.Name, "积分基线查询失败: 账号=%s err=%v", account.Name, err)
return
}
mu.Lock()
collected[account.Name] = score
mu.Unlock()
}(account)
}
wg.Wait()
if len(collected) == 0 {
return
}
if s.scoreBaselines != nil {
s.scoreBaselines.SetMany(collected)
}
logger.LogEvent("账号", "success", "已记录 %d 个账号的积分基线(用于抢购后核对是否扣分)", len(collected))
}
// logNetworkSummary 输出本次任务期间各类接口的聚合统计,替代逐条刷屏的网络日志。
func (s *Scheduler) logNetworkSummary(cli *client.DouyuClient) {
if cli == nil {
return
}
for _, stat := range cli.RequestStats() {
avg := time.Duration(0)
if stat.Count > 0 {
avg = stat.Total / time.Duration(stat.Count)
}
if stat.LastErr != "" {
logger.LogEvent("网络", "info", "接口统计: %s ×%d 失败%d 平均=%s 最慢=%s 最后错误=%s",
stat.Label, stat.Count, stat.Failed, utils.RoundDuration(avg), utils.RoundDuration(stat.Slowest), stat.LastErr)
continue
}
logger.LogEvent("网络", "info", "接口统计: %s ×%d 失败%d 平均=%s 最慢=%s",
stat.Label, stat.Count, stat.Failed, utils.RoundDuration(avg), utils.RoundDuration(stat.Slowest))
}
}
// 账号最终结束状态。
const (
outcomeSuccess = "success"
outcomeRejected = "rejected" // 窗口结束时商品始终售罄
outcomeThrottled = "throttled" // 窗口内始终被请求级限流
outcomeTerminal = "terminal" // 命中账号级终止条件
outcomeLockedUnpaid = "lockedUnpaid" // 已锁单成功但支付未完成
outcomeStopped = "stopped"
outcomeExpired = "expired"
// outcomeLimitReached 表示服务端回复"已达本次活动兑换上限"。
//
// 它不是失败:这个账号在本次活动里已经兑换成功过(2026-10-23 日志里
// 这类账号随后就报了"积分已扣减,兑换确认")。所以单列一栏,
// 既不计入失败数,也不混进"账号终止"。
outcomeLimitReached = "limitReached"
)
// 每账号重试节奏的上下限与递增倍数。
//
// 抢购是争分夺秒的,退避不能长:2026-10-03 的日志里,PC2 四个实例在
// 18:00:00.171~18:00:01.101 一直能锁到同一个礼包(库存至少活了 1.1 秒),
// 而 PC1 默认实例的 31 个号在 18:00:00.225 失败后一直睡到 18:01:09.379——
// 唯一有货的那段窗口被退避白白吃掉了。所以这里把任何一次等待都压在 2 秒以内。
const (
minRetryDelay = 100 * time.Millisecond
maxRetryDelay = 1500 * time.Millisecond
maxRetryEscalation = 4
)
// 被限流后的单账号降频阶梯。
//
// 2026-10-23 三机日志给出的硬证据:单实例锁单请求 950~1650 次(约 20 QPS)时,
// 有 18~24 个账号被"您点击太快";而锁单仅 148 次的实例 30 个账号一次全中。
// 可见"点击太快/活动火爆"是账号级封禁,继续按 100ms 节奏猛打只会加深封禁。
//
// 因此被限流的账号改走阶梯:第 1 次等待 1~2s,第 2 次 2~3s,第 3 次 3~4s……
// 逐级拉长,单账号独立生效——只压这一个账号自己的下一次尝试,
// 不影响其它账号的节奏(每个账号跑在自己的 goroutine 里)。
//
// 上限 5s:再慢就基本错过窗口内的库存回流了(库存通常只活 1~2 秒,
// 但补货/他人支付失败会让它回流)。
//
// 声明为变量是为了让测试能缩短时间尺度。
var (
throttleBackoffBase = 1 * time.Second
throttleBackoffStep = 1 * time.Second
throttleBackoffMax = 5 * time.Second
)
// 首发请求的错开参数:第 0 个账号立即发出,其余按小步长依次错开,
// 整批最多铺开 firstWaveSpread(账号再多也不会拖长),单个步长不超过 firstWaveMaxStep。
const (
firstWaveSpread = 300 * time.Millisecond
firstWaveMaxStep = 8 * time.Millisecond
)
// stockOutWarnAfter 是同一账号连续收到"商品已售罄"多少次后,打一条"转为低频探测"
// 的提示日志。它只影响提示,不影响是否继续重试。
//
// 刻意不因售罄而停止:别人锁单后支付失败或锁单过期,占用的库存会回流,
// 窗口内必须继续探测(旧实现里就有"库存耗尽不停止,斗鱼可能会补货"的结论)。
// "活动火爆/网络繁忙"则连提示都不打——2026-10-03 日志里同一实例、同一秒内
// 3 个账号对同一个 commodityID 锁单成功而另外 31 个被拒,说明那只是请求级限流。
const stockOutWarnAfter = 8
// accountOutcome 是单个账号的最终结果。
type accountOutcome struct {
account string
product types.Product
kind string
reason string
locked bool
}
// runAccountLoop 是单个账号的独立重试循环:锁单失败按配置节奏重试,
// 达到连续被拒上限或账号级终止条件时退出。
func (s *Scheduler) runAccountLoop(task types.ExchangeAttempt, settings runSettings, ctl *runControl) accountOutcome {
out := accountOutcome{account: task.Account.Name, product: task.Product}
// rejectStreak 只统计"该商品当前拿不到"的连续次数,用于停止判定;
// failStreak 统计所有连续失败,用于放大退避(两者混用会让频控/传输层错误
// 永远不递增,一路用配置里的最快节奏猛打)。
stockStreak := 0
stockOutWarned := false
failStreak := 0
// throttleStreak 统计连续被限流的次数,用于阶梯降频。
// 它与 failStreak 分开:只有"被限流"才值得拉长等待,普通失败仍走配置节奏。
throttleStreak := 0
attempts := 0
lastFailure := ""
lastStockOut := false
lastThrottled := false
for {
if ctl.stopped() {
out.kind, out.reason = outcomeStopped, "已收到停止指令"
return out
}
if ctl.expired() {
out.kind, out.reason = expiryOutcome(lastStockOut, lastThrottled, lastFailure)
if lastFailure != "" {
s.setResult(resultKey(task), "失败|"+out.reason)
}
return out
}
attempts++
task.Index = attempts
res := s.runAccountAttempt(task, settings.seckillMode, ctl)
out.locked = out.locked || res.locked
s.setResult(resultKey(task), res.result.Message)
if res.result.OK {
out.kind = outcomeSuccess
out.reason = res.result.Message
logger.LogAccountEvent("抢购", "success", out.account, "成功: 账号=%s 商品=%s 第%d次 %s",
out.account, res.result.Product, res.result.Attempt, res.result.Message)
s.enqueueSuccessImage(task.Account, task.Product, res.result.RoleName)
return out
}
if res.stopped {
out.kind, out.reason = outcomeStopped, "已收到停止指令"
return out
}
if res.limitReached {
// "已达本次活动兑换上限"= 这个账号在本次活动里已经换到过了。
// 它不是失败:2026-10-23 日志里这些账号紧接着就报了"积分已扣减,兑换确认"。
// 单独归类,既不计入失败,也不进入"账号终止"统计。
out.kind = outcomeLimitReached
out.reason = "已达本次活动兑换上限"
s.setResult(resultKey(task), "已抢到|"+out.reason)
logger.LogAccountEvent("抢购", "success", out.account,
"已达兑换上限(此前已兑换成功,不计为失败): 账号=%s 原因=%s", out.account, out.reason)
return out
}
if res.terminal {
out.kind, out.reason = outcomeTerminal, failureReason(res.result.Message)
logger.LogAccountEvent("抢购", "warn", out.account, "账号停止重试: 账号=%s 原因=%s", out.account, out.reason)
return out
}
if res.locked {
// 已锁单成功但支付没有完成:不再新建锁单,避免重复下单。
out.kind, out.reason = outcomeLockedUnpaid, failureReason(res.result.Message)
logger.LogAccountEvent("抢购", "warn", out.account, "锁单已占用,不再新建锁单: 账号=%s 原因=%s", out.account, out.reason)
return out
}
if res.notStarted {
// 活动还没开始:这次尝试不算数,也不消耗重试节奏、不触发降频。
// 用最短节奏重试,抢在活动开始的第一刻就发出有效请求。
//
// 2026-10-23 三机日志里 148 次"不在时间范围内"全部集中在
// 斗鱼估算时间 -0.026s ~ +0.172s,说明确实是发早了。
// 有了这道守卫,即使触发时刻有几毫秒误差,也不会白白耗掉账号的尝试次数。
delay := notStartedRetryDelay()
logger.LogAccountEvent("抢购", "info", out.account,
"活动尚未开始,%s 后重试(本次不计入失败): %s",
utils.RoundDuration(delay), failureReason(res.result.Message))
// 结果集里先前的"失败|不在时间范围内…"不能留着——
// 前端会把它显示成"失败"。改写成"等待活动开始",等真正有结论时再覆盖。
s.setResult(resultKey(task), "等待活动开始")
if !ctl.sleep(delay) {
if ctl.stopped() {
out.kind, out.reason = outcomeStopped, "已收到停止指令"
} else {
out.kind, out.reason = outcomeExpired, "抢购窗口已结束(活动始终未开始)"
s.setResult(resultKey(task), "失败|"+out.reason)
}
return out
}
// 关键:attempts 不加一,failStreak 不加一。
// 活动开始前的这些请求对"抢到没有"毫无参考价值。
continue
}
failStreak++
lastFailure = failureReason(res.result.Message)
lastStockOut = res.stockOut
lastThrottled = res.throttled
if res.stockOut {
stockStreak++
} else {
stockStreak = 0
}
if res.throttled {
throttleStreak++
} else {
// 非限流的失败把限流阶梯归零:只有连续被限流才应该越等越久。
throttleStreak = 0
}
// 售罄不等于终态:别人锁单后支付失败或锁单过期,库存会回流,
// 所以窗口内一律继续探测,只是退避会随连续失败自动降到秒级。
if stockStreak == stockOutWarnAfter && !stockOutWarned {
stockOutWarned = true
logger.LogAccountEvent("抢购", "warn", out.account,
"商品疑似售罄,转为低频探测直到窗口结束: 账号=%s 商品=%s(%s) 连续%d次 %s",
out.account, task.Product.CommodityName, task.Product.CommodityID, stockStreak, lastFailure)
}
var delay time.Duration
if res.throttled {
// 被限流:改走单账号阶梯降频(1~2s、2~3s、3~4s……)。
// 只影响本账号自己的下一次尝试,其它账号的节奏完全不受影响。
delay = throttleBackoff(throttleStreak)
logger.LogAccountEvent("抢购", "info", out.account,
"第%d次被限流,%s 后重试(本账号降频,不影响其它账号): %s",
attempts, utils.RoundDuration(delay), lastFailure)
} else {
delay = retryDelay(settings.retryStages, ctl.elapsed(), failStreak)
logger.LogAccountEvent("抢购", "info", out.account, "第%d次未成功,%s 后重试: %s",
attempts, utils.RoundDuration(delay), lastFailure)
}
if !ctl.sleep(delay) {
if ctl.stopped() {
out.kind, out.reason = outcomeStopped, "已收到停止指令"
} else {
out.kind, out.reason = expiryOutcome(lastStockOut, lastThrottled, lastFailure)
// 把分类后的结束原因写进结果集,账号表才看得出"售罄/限流"而不是原始错误。
s.setResult(resultKey(task), "失败|"+out.reason)
}
return out
}
}
}
// expiryOutcome 生成"抢购窗口结束"的结束原因,并带上最后一次失败。
//
// 必须区分售罄 / 被限流 / 普通失败:否则界面上只有一个孤零零的 0 成功,
// 看不出到底发生了什么(这正是 2026-10-03 的排查痛点)。
// 注意这里不提前停止——售罄后库存可能回流,必须探测到窗口结束。
func expiryOutcome(lastStockOut, lastThrottled bool, lastFailure string) (string, string) {
switch {
case lastFailure == "":
return outcomeExpired, "抢购窗口已结束"
case lastStockOut:
return outcomeRejected, "抢购窗口结束(商品始终售罄: " + lastFailure + ")"
case lastThrottled:
return outcomeThrottled, "抢购窗口结束(最后仍被限流: " + lastFailure + ")"
default:
return outcomeExpired, "抢购窗口结束(最后失败: " + lastFailure + ")"
}
}
// notStartedRetryDelay 是"活动尚未开始"时的重试间隔。
//
// 这类请求发得太早,斗鱼侧还没开闸:用最短节奏重试,抢在活动开始的第一刻
// 就发出有效请求即可。给一点随机抖动,避免所有账号在同一毫秒齐发。
const notStartedRetryMin = 50 * time.Millisecond
const notStartedRetryMax = 150 * time.Millisecond
func notStartedRetryDelay() time.Duration {
return randomSpan(notStartedRetryMin, notStartedRetryMax)
}
// throttleBackoff 计算账号被限流后的下一次等待时间(单账号级阶梯降频)。
//
// 只作用于当前这个账号:每个账号在各自的 goroutine 里独立重试,
// 因此拉长某个账号的等待不会占用并发额度,也不会拖慢其它账号。
//
// 阶梯:第 1 次限流等 1~2s,第 2 次 2~3s,第 3 次 3~4s……逐级拉长,
// 上限 5s。区间内随机取值,避免同一批账号同步醒来再次形成尖峰。
//
// 为什么不用普通的 retryDelay:那个函数按"经过秒数分档 + 成倍放大",
// 最快也要 100ms 就重试。2026-10-23 的日志显示,"您点击太快/活动火爆"
// 是账号级封禁——单实例锁单 950~1650 次时 18~24 个账号被限流,
// 而锁单仅 148 次的实例 30 个账号一次全中。猛打只会加深封禁。
func throttleBackoff(streak int) time.Duration {
if streak < 1 {
streak = 1
}
lower := throttleBackoffBase + time.Duration(streak-1)*throttleBackoffStep
if lower > throttleBackoffMax {
return throttleBackoffMax
}
upper := lower + throttleBackoffStep
if upper > throttleBackoffMax {
upper = throttleBackoffMax
}
if upper <= lower {
return lower
}
return lower + time.Duration(rand.Int63n(int64(upper-lower)+1))
}
// retryDelay 计算账号下一次尝试前的等待时间。
//
// 基准节奏来自配置的"重试间隔策略"(按经过秒数分档)——早期版本把它只用在
// 轮与轮之间,单次锁单失败却硬编码睡 30 秒,配置形同虚设。同一账号连续失败时
// 再成倍放大(最多 ×4),避免单个账号猛打;并叠加 0-25% 抖动,
// 防止所有账号同步重试形成尖峰。
//
// 上限刻意压到 1.5 秒:抢购窗口只有 75 秒,库存随时可能因为别人锁单未支付而回流,
// 任何超过 2 秒的等待都可能正好错过它。
func retryDelay(stages []types.RetryStage, elapsed time.Duration, failStreak int) time.Duration {
base := retryIntervalFor(stages, elapsed)
if base <= 0 {
base = 900 * time.Millisecond
}
mult := 1
for i := 1; i < failStreak && mult < maxRetryEscalation; i++ {
mult <<= 1
}
delay := time.Duration(mult) * base
if delay > maxRetryDelay {
delay = maxRetryDelay
}
if delay < minRetryDelay {
delay = minRetryDelay
}
return jitterFraction(delay, 4)
}
// resultKey 生成结果键。
//
// 后缀保持历史上的 `_第N包` 形态:前端 useLogs.ts / ControlStrip.vue 用
// /_第\d+包$/ 归并出账号名。这里固定第 1 包,保证每个账号只占一个结果条目
// ——早期实现每次尝试都写一个新键,重试几十次后结果集会膨胀到几千条。
func resultKey(attempt types.ExchangeAttempt) string {
return fmt.Sprintf("%s_第1包", attempt.Account.Name)
}
// failureReason 去掉结果里的"失败|"前缀,便于汇总展示。
func failureReason(message string) string {
return strings.TrimPrefix(message, "失败|")
}
// productTargets 汇总本次抢购的商品,并把 commodityID 打进日志。
// 2026-10-03 的排查正卡在"日志里没有 commodityID",无法判断各实例是否选了同一个 SKU。
func productTargets(tasks []types.ExchangeAttempt) []string {
order := make([]string, 0, 2)
names := make(map[string]string, 2)
counts := make(map[string]int, 2)
for _, task := range tasks {
id := task.Product.CommodityID
if _, ok := counts[id]; !ok {
order = append(order, id)
names[id] = task.Product.CommodityName
}
counts[id]++
}
out := make([]string, 0, len(order))
for _, id := range order {
out = append(out, fmt.Sprintf("商品=%s(%s) 账号=%d", names[id], id, counts[id]))
}
return out
}
// logRunSummary 输出按结束原因分类的汇总与真实请求次数。
func (s *Scheduler) logRunSummary(outcomes []accountOutcome, ctl *runControl, cost time.Duration) {
var success, rejected, throttled, terminal, lockedUnpaid, stopped, expired, limitReached int
reasons := make(map[string]int)
for _, out := range outcomes {
switch out.kind {
case outcomeSuccess:
success++
case outcomeRejected:
rejected++
case outcomeThrottled:
throttled++
case outcomeTerminal:
terminal++
case outcomeLockedUnpaid:
lockedUnpaid++
case outcomeStopped:
stopped++
case outcomeLimitReached:
// 已达兑换上限 = 此前已兑换成功,单列一栏,不计入失败。
limitReached++
default:
expired++
}
if out.kind != outcomeSuccess && out.kind != outcomeLimitReached && out.reason != "" {
reasons[out.reason]++
}
}
lockReqs, payReqs, exchangeReqs := ctl.counts()
logger.LogEvent("抢购", "info",
"抢购任务结束: 成功=%d/%d,已达兑换上限=%d,商品售罄=%d,被限流=%d,账号终止=%d,锁单未支付=%d,停止=%d,窗口结束=%d,耗时=%v",
success, len(outcomes), limitReached, rejected, throttled, terminal, lockedUnpaid, stopped, expired, utils.RoundDuration(cost))
logger.LogEvent("抢购", "info", "抢购请求统计: 锁单=%d,支付=%d,直接兑换=%d", lockReqs, payReqs, exchangeReqs)
type reasonCount struct {
reason string
count int
}
ranked := make([]reasonCount, 0, len(reasons))
for reason, count := range reasons {
ranked = append(ranked, reasonCount{reason: reason, count: count})
}
sort.Slice(ranked, func(i, j int) bool {
if ranked[i].count != ranked[j].count {
return ranked[i].count > ranked[j].count
}
return ranked[i].reason < ranked[j].reason
})
for _, item := range ranked {
logger.LogEvent("抢购", "warn", "未成功原因: %s × %d 个账号", item.reason, item.count)
}
}
// RunXiaodian 使用和平小店专用策略:固定次数、固定间隔、每轮直接调用 livebuy。
// 小店补货不依赖旧活动的 75 秒阶段窗口,也不执行手册的预检链路。
func (s *Scheduler) RunXiaodian(accountProducts map[string]string, attempts, delayMs int, reportSessionID string) {
defer s.finishRun()
s.ClearResults()
settings := s.settingsSnapshot()
attempts, delay := normalizeXiaodianRun(attempts, delayMs, settings.attempts)
accounts := make([]types.Account, 0, len(accountProducts))
products := make(map[string]types.Product, len(accountProducts))
for name := range accountProducts {
cookie, ok := s.AccountCookieByName(name)
if !ok {
continue
}
productID := accountProducts[name]
product := s.productForCommodityID(productID)
if product.CommodityID == "" {
product.CommodityID = productID
}
accounts = append(accounts, types.Account{Name: name, Cookie: cookie})
products[name] = product
}
if len(accounts) == 0 {
logger.LogEvent("抢购", "warn", "和平小店抢购没有可执行账号")
return
}
s.startXiaodianReport(accounts, products, reportSessionID)
stoppedAccounts := make(map[string]string)
cooldownAccounts := make(map[string]time.Time)
cooldownCount := make(map[string]int)
start := time.Now()
logger.LogEvent("抢购", "info", "和平小店抢购开始: %d 个账号,次数=%d,间隔=%dms",
len(accounts), attempts, delay.Milliseconds())
for round, waitBeforeRound := 1, false; round <= attempts; {
if s.runStopped() {
logger.LogEvent("抢购", "warn", "收到停止指令,和平小店抢购正在结束")
break
}
if waitBeforeRound && s.interruptibleSleep(delay) {
logger.LogEvent("抢购", "warn", "收到停止指令,和平小店抢购正在结束")
break
}
waitBeforeRound = false
roundAttempts := make([]types.ExchangeAttempt, 0, len(accounts))
for _, account := range accounts {
if stoppedAccounts[account.Name] != "" {
continue
}
product := products[account.Name]
roundAttempts = append(roundAttempts, types.ExchangeAttempt{
Account: account,
Product: product,
Index: round,
})
}
if len(roundAttempts) == 0 {
break
}
now := time.Now()
roundAttempts, nextReady := filterCooldownAttempts(roundAttempts, cooldownAccounts, now)
if len(roundAttempts) == 0 {
waitFor := nextReady.Sub(now)
if waitFor > 0 {
logger.LogEvent("抢购", "info", "和平小店第%d/%d轮账号冷却中,等待=%v", round, attempts, utils.RoundDuration(waitFor))
if s.interruptibleSleep(waitFor) {
logger.LogEvent("抢购", "warn", "收到停止指令,和平小店抢购正在结束")
break
}
}
continue
}
outcome := s.executeXiaodianRound(roundAttempts, settings)
s.updateXiaodianReport(outcome.results)
for name := range outcome.successAccounts {
stoppedAccounts[name] = "已抢到"
}
for name, reason := range outcome.stoppedAccounts {
if stoppedAccounts[name] == "" {
stoppedAccounts[name] = reason
logger.LogAccountEvent("抢购", "warn", name, "账号停止重试: 账号=%s 原因=%s", name, reason)
}
}
s.stopXiaodianReportAccounts(outcome.stoppedAccounts)
for name, until := range outcome.cooldownAccounts {
if stoppedAccounts[name] != "" || !until.After(cooldownAccounts[name]) {
continue
}
cooldownAccounts[name] = until
cooldownCount[name]++
logger.LogAccountEvent("抢购", "warn", name, "账号临时降频: 账号=%s 冷却至=%s (第%d次)",
name, until.In(constants.CST).Format("15:04:05.000"), cooldownCount[name])
if cooldownCount[name] >= maxCooldownCount {
stoppedAccounts[name] = "冷却次数过多"
logger.LogAccountEvent("抢购", "warn", name, "账号停止重试: 账号=%s 原因=冷却次数过多(%d次)", name, cooldownCount[name])
}
}
logger.LogEvent("抢购", "info", "和平小店第%d/%d轮完成: 成功=%d,账号停止=%d,冷却=%d,剩余账号=%d",
round, attempts, len(outcome.successAccounts), len(outcome.stoppedAccounts), len(outcome.cooldownAccounts), len(accounts)-len(stoppedAccounts))
if len(stoppedAccounts) >= len(accounts) {
break
}
round++
waitBeforeRound = true
}
logger.LogEvent("抢购", "info", "和平小店抢购结束: 成功或停止=%d/%d,耗时=%v",
len(stoppedAccounts), len(accounts), utils.RoundDuration(time.Since(start)))
s.finishXiaodianReport(s.runStopped())
}
func normalizeXiaodianRun(attempts, delayMs, fallbackAttempts int) (int, time.Duration) {
if attempts <= 0 {
attempts = fallbackAttempts
}
if attempts <= 0 {
attempts = 3
}
if attempts > 100000 {
attempts = 100000
}
if delayMs < 0 {
delayMs = 0
}
if delayMs == 0 {
delayMs = int(xiaodianDefaultDelay / time.Millisecond)
}
if delayMs > 60000 {
delayMs = 60000
}
return attempts, time.Duration(delayMs) * time.Millisecond
}
func filterCooldownAttempts(attempts []types.ExchangeAttempt, cooldownAccounts map[string]time.Time, now time.Time) ([]types.ExchangeAttempt, time.Time) {
out := make([]types.ExchangeAttempt, 0, len(attempts))
var nextReady time.Time
for _, attempt := range attempts {
until := cooldownAccounts[attempt.Account.Name]
if until.After(now) {
if nextReady.IsZero() || until.Before(nextReady) {
nextReady = until
}
continue
}
out = append(out, attempt)
}
return out, nextReady
}
func (s *Scheduler) executeXiaodianRound(attempts []types.ExchangeAttempt, settings runSettings) roundOutcome {
return s.executeRoundWithRunner(attempts, settings, s.runXiaodianAttempt)
}
func (s *Scheduler) executeRoundWithRunner(
attempts []types.ExchangeAttempt,
settings runSettings,
runner func(types.ExchangeAttempt) types.ExchangeResult,
) roundOutcome {
outcome := roundOutcome{
successAccounts: make(map[string]bool),
stoppedAccounts: make(map[string]string),
stoppedProducts: make(map[string]string),
cooldownAccounts: make(map[string]time.Time),
results: make(map[string]types.ExchangeResult),
}
var mu sync.Mutex
limit := make(chan struct{}, settings.concurrency)
var wg sync.WaitGroup
for _, attempt := range attempts {
if s.runStopped() {
break
}
wg.Add(1)
go func(attempt types.ExchangeAttempt) {
defer wg.Done()
if s.runStopped() {
return
}
limit <- struct{}{}
defer func() { <-limit }()
if s.runStopped() {
return
}
result := runner(attempt)
// 固定后缀:前端 useLogs/ControlStrip 按 /_第\d+包$/ 归并账号名。
// 用轮次做后缀时,抢购次数 >=10 会让前端按字典序取到中间某次的旧原因。
key := fmt.Sprintf("%s_第1包", result.Account)
s.setResult(key, result.Message)
if result.OK {
logger.LogAccountEvent("抢购", "success", result.Account, "成功: 账号=%s 商品=%s 第%d次 %s", result.Account, result.Product, result.Attempt, result.Message)
s.enqueueSuccessImage(attempt.Account, attempt.Product, result.RoleName)
} else {
logger.LogAccountEvent("抢购", "info", result.Account, "尝试: 账号=%s 商品=%s 第%d次 %s", result.Account, result.Product, result.Attempt, result.Message)
}
mu.Lock()
outcome.attempts++
outcome.results[attempt.Account.Name] = result
if result.OK {
outcome.successAccounts[attempt.Account.Name] = true
} else {
if cooldown := retryCooldownDuration(result.Message); cooldown > 0 {
outcome.cooldownAccounts[attempt.Account.Name] = time.Now().Add(jitterDuration(cooldown))
}
terminalAccount, terminalProduct, reason := classifyXiaodianRetryStop(result.Message)
if terminalAccount {
outcome.stoppedAccounts[attempt.Account.Name] = reason
}
if terminalProduct {
outcome.stoppedProducts[attempt.Product.CommodityID] = reason
}
}
mu.Unlock()
}(attempt)
}
wg.Wait()
return outcome
}
// ==================== 辅助函数 ====================
// retryIntervalFor 根据配置的重试阶段计算当前应该使用的重试间隔。
func retryIntervalFor(retryStages []types.RetryStage, elapsed time.Duration) time.Duration {
elapsedSec := int(elapsed.Seconds())
// 使用配置的阶段
for _, stage := range retryStages {
if stage.MaxElapsed > 0 && elapsedSec < stage.MaxElapsed && stage.Interval > 0 {
return time.Duration(stage.Interval) * time.Millisecond
}
}
// 默认值(如果没有配置或配置无效)
return 900 * time.Millisecond
}
func jitterDuration(base time.Duration) time.Duration {
return jitterFraction(base, 10)
}
func retryCooldownDuration(message string) time.Duration {
if exchangeRateLimited(message) {
return exchangeRateCooldown
}
if strings.Contains(message, "锁定兑换商品失败") || strings.Contains(message, "支付失败") {
return peaceLockRetryFallback
}
return 0
}
func classifyRetryStop(message string) (account bool, product bool, reason string) {
switch {
case strings.Contains(message, "商品本次活动库存已耗完"):
// 库存耗尽不停止,继续重试(斗鱼可能会补货)
return false, false, ""
case strings.Contains(message, "您已达本次活动兑换上限"):
return true, false, "已达兑换上限"
case strings.Contains(message, "未绑定账号"):
return true, false, "账号未绑定角色"
case strings.Contains(message, "需要开通精英手册"):
return true, false, "账号不满足精英手册条件"
default:
return false, false, ""
}
}
func classifyXiaodianRetryStop(message string) (account bool, product bool, reason string) {
switch {
case strings.Contains(message, "Livelink登录态校验失败"),
strings.Contains(message, "Livelink") && strings.Contains(message, "登录态校验失败"):
return true, false, "和平小店绑定已失效,需重新绑定"
case strings.Contains(message, "余额不足"),
strings.Contains(message, "点券不足"):
return true, false, "点券余额不足"
case strings.Contains(message, "已拥有该道具"),
strings.Contains(message, "已经拥有该道具"),
strings.Contains(message, "已拥有该商品"):
return true, false, "账号已拥有该道具"
case strings.Contains(message, "未绑定账号"):
return true, false, "账号未绑定角色"
case strings.Contains(message, "商品不存在"),
strings.Contains(message, "商品已下架"),
strings.Contains(message, "不支持该商品"):
return false, true, "商品不可兑换"
default:
return false, false, ""
}
}
// recordCalibrationOffset 记录校准偏移,保留最近N次用于中位数平滑。
func (s *Scheduler) recordCalibrationOffset(offset time.Duration) {
s.calibrationMu.Lock()
defer s.calibrationMu.Unlock()
s.calibrationOffsets = append(s.calibrationOffsets, offset)
if len(s.calibrationOffsets) > calibrationHistorySize {
s.calibrationOffsets = s.calibrationOffsets[len(s.calibrationOffsets)-calibrationHistorySize:]
}
}
// smoothedOffset 返回最近校准偏移的中位数,过滤跳变异常。
func (s *Scheduler) smoothedOffset() time.Duration {
s.calibrationMu.Lock()
defer s.calibrationMu.Unlock()
if len(s.calibrationOffsets) == 0 {
return 0
}
sorted := append([]time.Duration(nil), s.calibrationOffsets...)
sort.Slice(sorted, func(i, j int) bool { return sorted[i] < sorted[j] })
return sorted[len(sorted)/2]
}
// dynamicAdvance 计算触发时刻相对目标时间的提前量。
//
// 2026-10-23 之前这里按"误差边界 + RTT/2"提前约 100ms 触发,想用这点提前量
// 抵消网络耗时。但实测证明它有害:提前发出的请求会被斗鱼明确拒绝——
// 三机日志里 148 次"不在时间范围内 不能兑换",全部落在斗鱼估算时间
// -0.026s ~ +0.172s,也就是活动还没开闸就冲进去了。
//
// 提前抢到的是"活动开始前"的时间点,那里根本没有库存;而精确命中 18:00:00
// 才是服务端开闸的时刻。所以这里不再提前:提前量固定为 0,精确命中目标时刻。
//
// 触发后仍有一道兜底(runAccountLoop 里的"活动尚未开始"守卫):
// 万一本地时钟有几毫秒误差导致发早了,那个请求不算失败、不消耗重试次数、
// 也不触发降频,而是用 50~150ms 的节奏快速重试,直到活动真正开始。
func dynamicAdvance(calibration types.TimeCalibration) time.Duration {
// 精确命中:不提前。
return 0
}
// buildTasks 为每个账号生成一个抢购任务。
//
// 锁单+支付链路下,一次任务就是一次完整的"锁单→支付",不需要再按"N 个包"
// 为同一账号重复生成任务(历史实现会因此把预热缓存日志打两遍)。
func (s *Scheduler) buildTasks(accountProducts map[string]string) []types.ExchangeAttempt {
accounts := s.AccountSnapshot()
tasks := make([]types.ExchangeAttempt, 0, len(accounts))
for _, account := range accounts {
commodityID := accountProducts[account.Name]
if commodityID == "" {
continue
}
tasks = append(tasks, types.ExchangeAttempt{
Account: account,
Product: s.productForCommodityID(commodityID),
Index: 1,
})
}
return tasks
}
func (s *Scheduler) productForCommodityID(commodityID string) types.Product {
s.productsMu.RLock()
product, ok := s.products[commodityID]
s.productsMu.RUnlock()
if ok {
if product.CommodityName == "" {
product.CommodityName = commodityID
}
return product
}
return types.Product{CommodityID: commodityID, CommodityName: commodityID}
}
func (s *Scheduler) enqueueSuccessImage(account types.Account, product types.Product, roleName string) {
if s.successImages == nil {
return
}
s.successImages.Enqueue(account, product, roleName)
}
// scoreBaselinePath 返回积分基线文件路径:与账号库同目录。
// 账号库路径为空时返回空串,基线退化为纯内存,避免写到当前工作目录。
func scoreBaselinePath(accountFile string) string {
if strings.TrimSpace(accountFile) == "" {
return ""
}
dir := filepath.Dir(accountFile)
if dir == "" {
dir = "."
}
return filepath.Join(dir, scoreBaselineFileName)
}