package seckill import ( "fmt" "math/rand" "sort" "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 = 3 * time.Second calibrationHistorySize = 3 seckillMaxDuration = 75 * time.Second behaviorCooldown = 5 * time.Second clickFastCooldown = 3 * time.Second minInternalAdvance = 50 * time.Millisecond maxCooldownCount = 5 xiaodianDefaultDelay = 500 * time.Millisecond ) type roundOutcome struct { successAccounts map[string]bool stoppedAccounts map[string]string stoppedProducts map[string]string cooldownAccounts map[string]time.Time 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 resultsMu sync.RWMutex results map[string]string 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 warmupGen int64 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 } return &Scheduler{ client: cli, paths: paths, font: font, accounts: NewAccountStore(paths.AccountFile, paths.LegacyAccountFile), 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), } } // Close 关闭调度器的后台资源。 func (s *Scheduler) Close() { if s.successImages != nil { s.successImages.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) } 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 立即执行抢购任务,持续循环直到超时或全部成功。 func (s *Scheduler) RunNow(accountProducts map[string]string) { defer s.finishRun() s.ClearResults() settings := s.settingsSnapshot() allAttempts := s.buildAttempts(accountProducts, settings.attempts) if len(allAttempts) == 0 { logger.LogEvent("抢购", "warn", "没有可执行的抢购任务") return } successAccounts := make(map[string]bool) stoppedAccounts := make(map[string]string) stoppedProducts := make(map[string]string) cooldownAccounts := make(map[string]time.Time) cooldownCount := make(map[string]int) totalAccounts := uniqueAttemptAccounts(allAttempts) totalAttempts := 0 startTime := time.Now() round := 0 s.clearAttemptCache() if settings.seckillMode == types.SeckillModeAggressive { s.initCacheFromWarmup(allAttempts) } logger.LogEvent("抢购", "info", "开始抢购: %d 个账号,窗口=%v,预检通过后直兑,前段高频后段降速", totalAccounts, seckillMaxDuration) for { if s.runStopped() { logger.LogEvent("抢购", "warn", "收到停止指令,抢购任务正在结束") break } elapsed := time.Since(startTime) if elapsed >= seckillMaxDuration { logger.LogEvent("抢购", "info", "已达到抢购窗口 %v,停止抢购", seckillMaxDuration) break } round++ remaining := seckillMaxDuration - elapsed pendingAttempts := s.filterPendingAttempts(allAttempts, stoppedAccounts, stoppedProducts) if len(pendingAttempts) == 0 { logger.LogEvent("抢购", "info", "所有账号都已成功或遇到终止条件,停止抢购") break } roundAttempts := pickRoundAttempts(pendingAttempts, round, settings.attempts) if len(roundAttempts) == 0 { logger.LogEvent("抢购", "info", "第%d轮无可执行账号,停止抢购", round) break } now := time.Now() roundAttempts, nextReady := filterCooldownAttempts(roundAttempts, cooldownAccounts, now) if len(roundAttempts) == 0 { sleepFor := nextReady.Sub(now) if sleepFor <= 0 { sleepFor = retryIntervalFor(settings.retryStages, time.Since(startTime)) } if sleepFor > remaining { sleepFor = remaining } if sleepFor > 0 { logger.LogEvent("抢购", "info", "第%d轮账号冷却中,等待=%v", round, utils.RoundDuration(sleepFor)) if s.interruptibleSleep(sleepFor) { logger.LogEvent("抢购", "warn", "收到停止指令,抢购任务正在结束") break } } continue } logger.LogEvent("抢购", "info", "第%d轮: 待抢购 %d 个账号,本轮执行=%d,剩余时间=%v,模式=%s", round, uniqueAttemptAccounts(pendingAttempts), len(roundAttempts), utils.RoundDuration(remaining), modeName(settings.seckillMode)) outcome := s.executeRound(roundAttempts, settings) totalAttempts += outcome.attempts for account := range outcome.successAccounts { successAccounts[account] = true stoppedAccounts[account] = "已抢到" } for account, reason := range outcome.stoppedAccounts { if stoppedAccounts[account] == "" { stoppedAccounts[account] = reason logger.LogAccountEvent("抢购", "warn", account, "账号停止重试: 账号=%s 原因=%s", account, reason) } } for product, reason := range outcome.stoppedProducts { if stoppedProducts[product] == "" { stoppedProducts[product] = reason logger.LogEvent("抢购", "warn", "商品停止重试: %s,原因=%s", product, reason) } } for account, until := range outcome.cooldownAccounts { if until.After(cooldownAccounts[account]) { cooldownAccounts[account] = until cooldownCount[account]++ logger.LogAccountEvent("抢购", "warn", account, "账号临时降频: 账号=%s 冷却至=%s (第%d次)", account, until.In(constants.CST).Format("15:04:05.000"), cooldownCount[account]) if cooldownCount[account] >= maxCooldownCount { stoppedAccounts[account] = "冷却次数过多" logger.LogAccountEvent("抢购", "warn", account, "账号停止重试: 账号=%s 原因=冷却次数过多(%d次)", account, cooldownCount[account]) } } } if s.runStopped() { logger.LogEvent("抢购", "warn", "收到停止指令,抢购任务正在结束") break } if len(outcome.successAccounts) > 0 { logger.LogEvent("抢购", "success", "第%d轮成功: %d 个账号", round, len(outcome.successAccounts)) } if len(stoppedAccounts) >= totalAccounts { logger.LogEvent("抢购", "info", "所有账号都已成功或停止重试,停止抢购") break } retryInterval := retryIntervalFor(settings.retryStages, time.Since(startTime)) if retryInterval > 0 && time.Since(startTime)+retryInterval < seckillMaxDuration { if s.interruptibleSleep(jitterDuration(retryInterval)) { logger.LogEvent("抢购", "warn", "收到停止指令,抢购任务正在结束") break } } } logger.LogEvent("抢购", "info", "抢购任务结束: 成功=%d/%d,停止=%d,账号尝试=%d,耗时=%v", len(successAccounts), totalAccounts, len(stoppedAccounts)-len(successAccounts), totalAttempts, utils.RoundDuration(time.Since(startTime))) } // RunFixed 按固定轮数和轮间隔抢购,账号成功后不再参与后续轮次。 func (s *Scheduler) RunFixed(accountProducts map[string]string, attempts, delayMs int) { defer s.finishRun() s.ClearResults() settings := s.settingsSnapshot() if attempts < 1 { attempts = 1 } if attempts > 100000 { attempts = 100000 } if delayMs < 0 { delayMs = 0 } if delayMs > 60000 { delayMs = 60000 } accounts := make([]types.Account, 0, len(accountProducts)) for name, commodityID := range accountProducts { cookie, ok := s.AccountCookieByName(name) if !ok { continue } product := s.productForCommodityID(commodityID) if product.CommodityID == "" { product.CommodityID = commodityID } accounts = append(accounts, types.Account{Name: name, Cookie: cookie}) } if len(accounts) == 0 { logger.LogEvent("抢购", "warn", "固定次数抢购没有可执行账号") return } stopped := make(map[string]bool) start := time.Now() logger.LogEvent("抢购", "info", "固定次数抢购开始: %d 个账号,次数=%d,间隔=%dms", len(accounts), attempts, delayMs) for round := 1; round <= attempts; round++ { if s.runStopped() { logger.LogEvent("抢购", "warn", "收到停止指令,固定次数抢购正在结束") break } roundAttempts := make([]types.ExchangeAttempt, 0, len(accounts)) for _, account := range accounts { if stopped[account.Name] { continue } commodityID := accountProducts[account.Name] product := s.productForCommodityID(commodityID) if product.CommodityID == "" { product.CommodityID = commodityID } roundAttempts = append(roundAttempts, types.ExchangeAttempt{Account: account, Product: product, Index: round}) } if len(roundAttempts) == 0 { break } if round > 1 && delayMs > 0 { if s.interruptibleSleep(time.Duration(delayMs) * time.Millisecond) { logger.LogEvent("抢购", "warn", "收到停止指令,固定次数抢购正在结束") break } } outcome := s.executeRound(roundAttempts, settings) for name := range outcome.successAccounts { stopped[name] = true } for name := range outcome.stoppedAccounts { stopped[name] = true } logger.LogEvent("抢购", "info", "固定抢购第%d/%d轮完成: 成功=%d,剩余账号=%d", round, attempts, len(outcome.successAccounts), len(accounts)-len(stopped)) } logger.LogEvent("抢购", "info", "固定次数抢购结束: 成功=%d/%d,耗时=%v", len(stopped), len(accounts), utils.RoundDuration(time.Since(start))) } // RunXiaodian 使用和平小店专用策略:固定次数、固定间隔、每轮直接调用 livebuy。 // 小店补货不依赖旧活动的 75 秒阶段窗口,也不执行手册的预检链路。 func (s *Scheduler) RunXiaodian(accountProducts map[string]string, attempts, delayMs int) { defer s.finishRun() s.ClearResults() settings := s.settingsSnapshot() attempts, delay := normalizeXiaodianRun(attempts, delayMs, settings.attempts) accounts := make([]types.Account, 0, len(accountProducts)) for name := range accountProducts { cookie, ok := s.AccountCookieByName(name) if !ok { continue } accounts = append(accounts, types.Account{Name: name, Cookie: cookie}) } if len(accounts) == 0 { logger.LogEvent("抢购", "warn", "和平小店抢购没有可执行账号") return } stopped := make(map[string]bool) start := time.Now() logger.LogEvent("抢购", "info", "和平小店抢购开始: %d 个账号,次数=%d,间隔=%dms", len(accounts), attempts, delay.Milliseconds()) for round := 1; round <= attempts; round++ { if s.runStopped() { logger.LogEvent("抢购", "warn", "收到停止指令,和平小店抢购正在结束") break } if round > 1 && s.interruptibleSleep(delay) { logger.LogEvent("抢购", "warn", "收到停止指令,和平小店抢购正在结束") break } roundAttempts := make([]types.ExchangeAttempt, 0, len(accounts)) for _, account := range accounts { if stopped[account.Name] { continue } productID := accountProducts[account.Name] product := s.productForCommodityID(productID) if product.CommodityID == "" { product.CommodityID = productID } roundAttempts = append(roundAttempts, types.ExchangeAttempt{ Account: account, Product: product, Index: round, }) } if len(roundAttempts) == 0 { break } outcome := s.executeXiaodianRound(roundAttempts, settings) for name := range outcome.successAccounts { stopped[name] = true } for name := range outcome.stoppedAccounts { stopped[name] = true } logger.LogEvent("抢购", "info", "和平小店第%d/%d轮完成: 成功=%d,停止=%d,剩余账号=%d", round, attempts, len(outcome.successAccounts), len(outcome.stoppedAccounts), len(accounts)-len(stopped)) if len(stopped) >= len(accounts) { break } } logger.LogEvent("抢购", "info", "和平小店抢购结束: 成功或停止=%d/%d,耗时=%v", len(stopped), len(accounts), utils.RoundDuration(time.Since(start))) } 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 } // filterPendingAttempts 过滤掉已终止账号和已确认无库存的商品。 func (s *Scheduler) filterPendingAttempts(allAttempts []types.ExchangeAttempt, stoppedAccounts, stoppedProducts map[string]string) []types.ExchangeAttempt { var pending []types.ExchangeAttempt for _, attempt := range allAttempts { if stoppedAccounts[attempt.Account.Name] != "" { continue } if stoppedProducts[attempt.Product.CommodityID] != "" { continue } pending = append(pending, attempt) } return pending } 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 } // pickRoundAttempts 每轮每个账号最多执行一次,避免同账号并发过猛触发频控。 func pickRoundAttempts(attempts []types.ExchangeAttempt, round, attemptsPerAccount int) []types.ExchangeAttempt { if len(attempts) == 0 { return nil } preferredIndex := 1 if attemptsPerAccount > 0 { preferredIndex = ((round - 1) % attemptsPerAccount) + 1 } byAccount := make(map[string]types.ExchangeAttempt) fallback := make(map[string]types.ExchangeAttempt) order := make([]string, 0, len(attempts)) for _, attempt := range attempts { name := attempt.Account.Name if _, ok := fallback[name]; !ok { fallback[name] = attempt order = append(order, name) } if attempt.Index == preferredIndex { byAccount[name] = attempt } } out := make([]types.ExchangeAttempt, 0, len(order)) for _, name := range order { if attempt, ok := byAccount[name]; ok { out = append(out, attempt) } else { out = append(out, fallback[name]) } } return out } // executeRound 执行一轮抢购,并返回成功和终止重试的账号。 func (s *Scheduler) executeRound(attempts []types.ExchangeAttempt, settings runSettings) roundOutcome { return s.executeRoundWithRunner(attempts, settings, nil) } 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), } 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 } var result types.ExchangeResult if runner != nil { result = runner(attempt) } else if settings.seckillMode == types.SeckillModeAggressive { result = s.runAttemptFast(attempt) } else { result = s.runAttempt(attempt) } key := fmt.Sprintf("%s_第%d包", result.Account, result.Attempt) 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++ 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 := classifyRetryStop(result.Message) if runner != nil { 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 } // ==================== 辅助函数 ==================== // modeName 返回抢购模式名称。 func modeName(mode types.SeckillMode) string { if mode == types.SeckillModeAggressive { return "激进" } return "标准" } // 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 { if base <= 0 { return 0 } jitter := time.Duration(rand.Int63n(int64(base / 10))) return base + jitter } func retryCooldownDuration(message string) time.Duration { switch { case strings.Contains(message, "用户行为异常"): return behaviorCooldown case strings.Contains(message, "点击太快"): return clickFastCooldown case strings.Contains(message, "操作频繁"): return behaviorCooldown case strings.Contains(message, "请求过多"): return behaviorCooldown case strings.Contains(message, "请求太频繁"): return behaviorCooldown default: 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, "已拥有该道具"), 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 根据校准误差边界和 RTT 计算动态提前量,最少 50ms。 func dynamicAdvance(calibration types.TimeCalibration) time.Duration { advance := calibration.ErrorBound + calibration.RTT/2 if advance < minInternalAdvance { advance = minInternalAdvance } return advance } func uniqueAttemptAccounts(attempts []types.ExchangeAttempt) int { seen := make(map[string]struct{}, len(attempts)) for _, attempt := range attempts { seen[attempt.Account.Name] = struct{}{} } return len(seen) } func (s *Scheduler) buildAttempts(accountProducts map[string]string, attemptsPerAccount int) []types.ExchangeAttempt { if attemptsPerAccount <= 0 { attemptsPerAccount = constants.DefaultAttempts } accounts := s.AccountSnapshot() var attempts []types.ExchangeAttempt for _, account := range accounts { commodityID := accountProducts[account.Name] if commodityID == "" { continue } product := s.productForCommodityID(commodityID) for i := 1; i <= attemptsPerAccount; i++ { attempts = append(attempts, types.ExchangeAttempt{ Account: account, Product: product, Index: i, }) } } return attempts } 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) }