Files
go-sms-V2/internal/pkg/cronx/cronx.go
T

123 lines
2.5 KiB
Go

// Package cronx 轻量周期任务调度器(Day 27):每 Job 一协程 ticker,
// 支持 Start/Stop 与停止后重启(验收:定时器可停启);不引第三方依赖。
package cronx
import (
"context"
"fmt"
"sync"
"time"
)
// errPanic recover 值转错误。
func errPanic(r any) error {
if e, ok := r.(error); ok {
return fmt.Errorf("cronx: job panic: %w", e)
}
return fmt.Errorf("cronx: job panic: %v", r)
}
// Job 周期任务;Interval <=0 拒绝;Run 返回错误经 OnError 上报(nil 则忽略)。
type Job struct {
Name string
Interval time.Duration
Immediate bool // Start 后立即执行一次(不等首个 tick)
Run func(ctx context.Context) error
OnError func(name string, err error)
}
// Scheduler 任务集合;Start 幂等,Stop 幂等且等待全部退出。
type Scheduler struct {
mu sync.Mutex
jobs []Job
cancel context.CancelFunc
wg sync.WaitGroup
started bool
}
// Add 注册任务(仅未启动时允许;启动后再 Add 返回 false)。
func (s *Scheduler) Add(j Job) bool {
if j.Interval <= 0 || j.Run == nil {
return false
}
s.mu.Lock()
defer s.mu.Unlock()
if s.started {
return false
}
s.jobs = append(s.jobs, j)
return true
}
// Start 启动全部任务(每任务一协程);重复调用无效果。
func (s *Scheduler) Start() {
s.mu.Lock()
if s.started {
s.mu.Unlock()
return
}
s.started = true
ctx, cancel := context.WithCancel(context.Background())
s.cancel = cancel
jobs := append([]Job(nil), s.jobs...)
s.wg.Add(len(jobs))
s.mu.Unlock()
for _, j := range jobs {
go func(j Job) {
defer s.wg.Done()
if j.Immediate {
s.runOnce(ctx, j)
}
t := time.NewTicker(j.Interval)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
s.runOnce(ctx, j)
}
}
}(j)
}
}
// runOnce 执行一次并兜底 panic,错误交 OnError。
func (s *Scheduler) runOnce(ctx context.Context, j Job) {
defer func() {
if r := recover(); r != nil {
if j.OnError != nil {
j.OnError(j.Name, errPanic(r))
}
}
}()
if err := j.Run(ctx); err != nil && j.OnError != nil {
j.OnError(j.Name, err)
}
}
// Stop 停止并等待全部任务退出;可再次 Start(重启)。
func (s *Scheduler) Stop() {
s.mu.Lock()
if !s.started {
s.mu.Unlock()
return
}
cancel := s.cancel
s.started = false
s.cancel = nil
s.mu.Unlock()
if cancel != nil {
cancel()
}
s.wg.Wait()
}
// Started 是否运行中(测试用)。
func (s *Scheduler) Started() bool {
s.mu.Lock()
defer s.mu.Unlock()
return s.started
}