myth/task.go

package myth

import (
	"container/list"
	"context"
	"log"
	"time"
)

// TaskFunc 任务执行函数
type TaskFunc func(ctx context.Context, name string, now time.Time)

// 任务主体
type Task struct {
	Seconds int64
	l       *list.List
}

// Tasker 任务接口
type Tasker interface {
	// 任务名称
	Name() string

	// 执行任务时间间隔(秒)
	//  返回值
	//    = 0 时为指定时间执行的任务
	Interval() uint64

	// 每天指定时间执行的任务(hour:minute:second 时刻执行)
	//  返回值
	//    hour 小时( -1 时, 每小时定时执行)
	//    minute 分钟
	//    second 秒
	Timing() (hour, minute, second int)

	// 新增任务回调
	//AddTask(handle TaskHandle)

	// 任务回调
	//Task() TaskHandle

	// 执行任务(go 执行)
	//  参数
	//    now 当前时间
	//    hour 当前时间小时
	//    minute 当前时间分钟
	//    second 当前时间秒
	Do(ctx context.Context, now time.Time, hour, minute, second int)
}

// NewTask 新任务
func NewTask() *Task {
	return &Task{l: list.New()}
}

// Add 加入新任务
func (t *Task) Add(tx Tasker) {
	t.l.PushBack(tx)
}

func (t *Task) do(ctx context.Context, nsec int64) {
	var (
		interval             uint64
		hour, minute, second int
	)

	now := time.Now()

	h := now.Hour()
	m := now.Minute()
	s := now.Second()

	t.Seconds++

	for e := t.l.Front(); e != nil; e = e.Next() {
		v, _ := e.Value.(Tasker)
		interval = v.Interval()
		if interval > 1 {
			if nsec%int64(interval) == 0 {
				go v.Do(ctx, now, h, m, s)
			}
			continue
		} else if interval == 1 { // 每秒任务
			go v.Do(ctx, now, h, m, s)
			continue
		}

		// 小时、天任务
		hour, minute, second = v.Timing()
		if second == s {
			if minute == m {
				switch hour {
				case h:
					// 指定 时、分、秒 任务(每天)
					go v.Do(ctx, now, h, m, s)
				case -1:
					// 整点(小时)任务
					go v.Do(ctx, now, h, m, s)
				}
			}
		}
	}
}

func (t *Task) Start(ctx context.Context) {
	defer func() {
		if rcv := recover(); rcv != nil {
			log.Println("Task recover()", rcv)
		}
	}()

	ts := time.NewTicker(1 * time.Second)
	nsecs := int64(0)
	for {
		select {
		case <-ctx.Done():
			log.Println("Task Exit", ctx.Err())
			ts.Stop()
			return
		case <-ts.C:
			t.do(ctx, nsecs)
			nsecs++
		}
	}
}

// ***************** TaskElement begin *****************
// TaskElement 任务
type TaskElement struct {
	// 任务名称
	TaskName string
	// 任务执行间隔时间(秒)
	//  > 1 超 1 秒
	//  = 1 每秒
	//  = 0 每天、小时任务(时、分、秒 需要有效指定)
	//  < 1 指定时间
	TimeInterval uint64

	// -1 整点任务 (TimeInterval < 1)
	// >= 0 指定执行小时时间(0-23 有效, TimeInterval = 0)
	Hour int
	// 指定执行分钟时间(0-60 有效)
	Minute int
	// 指定执行秒时间(0-60 有效)
	Second int

	// N int64

	Handle TaskFunc
}

func (t TaskElement) Name() string {
	return t.TaskName
}

func (t TaskElement) Interval() uint64 {
	return t.TimeInterval
}

func (t TaskElement) Timing() (hour, minute, second int) {
	return t.Hour, t.Minute, t.Second
}

func (t *TaskElement) AddTask(handle TaskFunc) {
	t.Handle = handle
}

func (t *TaskElement) TaskHandle() TaskFunc {
	return t.Handle
}

func (t *TaskElement) Do(ctx context.Context, now time.Time, hour, minute, second int) {
	t.Handle(ctx, t.TaskName, now)
}

// ***************** TaskElement end *****************

// NewSecondTasker new
func NewSecondTask(name string, secs uint64, handle TaskFunc) *TaskElement {
	return &TaskElement{TaskName: name, Handle: handle, TimeInterval: secs}
}

// NewSecondTask new
func NewMinuteTask(name string, mins uint64, handle TaskFunc) *TaskElement {
	return &TaskElement{TaskName: name, Handle: handle, TimeInterval: 60 * mins}
}

// NewHourTask new
func NewHourTask(name string, handle TaskFunc) *TaskElement {
	return &TaskElement{TaskName: name, Handle: handle, Hour: -1, Minute: 0, Second: 0}
}

// NewSecondTasker new
func NewDailyTask(name string, hour, minute, second int, handle TaskFunc) *TaskElement {
	return &TaskElement{TaskName: name, Handle: handle, Hour: hour, Minute: minute, Second: second, TimeInterval: 0}
}