123 lines
2.5 KiB
Go
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
|
|
}
|