dy-admin-temp/internal/pcmserver/pkg/crontab/crontab.go

package crontab

import (
	"errors"
	"github.com/robfig/cron/v3"
	"sync"
)

var (
	ErrParam = errors.New("没有传递必要的参数")
)

// cronManageInstance
// 全局唯一实例
var cronManageInstance *CronManage

// CronManage
// 定时任务管理器类型 单例
type CronManage struct {
	crons map[string]*CronJobs
	mutex *sync.Mutex
}

// NewCronManage
// 创建管理器
func NewCronManage() *CronManage {
	if cronManageInstance != nil {
		return cronManageInstance
	}

	cronManageInstance = &CronManage{
		crons: make(map[string]*CronJobs),
		mutex: &sync.Mutex{},
	}

	return cronManageInstance
}

// GetCron
// 创建定时管理器
func GetCron(cronName string) *CronJobs {
	if cj, ok := cronManageInstance.getCronJobs(cronName); ok {
		return cj
	}

	cj := newCronJobs(cronName)
	cronManageInstance.setCronJobs(cronName, cj)
	return cj

}

func GetCrons() map[string]*CronJobs {
	return cronManageInstance.crons
}

func (cm *CronManage) getCronJobs(cronName string) (*CronJobs, bool) {
	cm.mutex.Lock()
	defer cm.mutex.Unlock()
	cj, ok := cm.crons[cronName]
	return cj, ok
}

func (cm *CronManage) setCronJobs(cronName string, cj *CronJobs) {
	cm.mutex.Lock()
	defer cm.mutex.Unlock()
	cm.crons[cronName] = cj
}

// DestroyCronManage 销毁实例
func DestroyCronManage() {
	for _, cronJobs := range cronManageInstance.crons {
		cronJobs.Destroy()
	}

	cronManageInstance.crons = make(map[string]*CronJobs)
}

type CronJobs struct {
	// 定时器名称
	name string
	// 定时器句柄
	cronHandle *cron.Cron
	// 此定时器中启动的工作任务
	jobs map[string]int
	// map锁
	mutex *sync.Mutex
}

type JobInfo struct {
	JobName  string `json:"jobName"`
	JobId    string `json:"jobId"`
	NextTime string `json:"nextTime"`
	Valid    bool   `json:"valid"`
}

func newCronJobs(name string) *CronJobs {
	cronHandle := cron.New(cron.WithSeconds())
	cronHandle.Start()
	return &CronJobs{
		name:       name,
		cronHandle: cronHandle,
		jobs:       make(map[string]int),
		mutex:      &sync.Mutex{},
	}
}

func (cj *CronJobs) getCronHandle() *cron.Cron {
	return cj.cronHandle
}

func (cj *CronJobs) getJobID(jobName string) (int, bool) {
	cj.mutex.Lock()
	defer cj.mutex.Unlock()
	jobID, ok := cj.jobs[jobName]
	return jobID, ok
}

func (cj *CronJobs) setJobID(jobName string, jobID int) {
	cj.mutex.Lock()
	defer cj.mutex.Unlock()
	cj.jobs[jobName] = jobID
}

func (cj *CronJobs) deleteJobID(jobName string) {
	cj.mutex.Lock()
	defer cj.mutex.Unlock()
	delete(cj.jobs, jobName)
}

// AddJobWithNoParams
// 新增任务,任务处理函数无需参数
func (cj *CronJobs) AddJobWithNoParams(jobName string, spec string, jobFunc func()) error {
	if jobName == "" || spec == "" || jobFunc == nil {
		return ErrParam
	}

	if _, ok := cj.getJobID(jobName); ok {
		return nil
	}

	entryID, err := cj.cronHandle.AddFunc(spec, jobFunc)
	if err != nil {
		return err
	}

	cj.setJobID(jobName, int(entryID))

	return nil
}

// AddJobWithParams
// 新增任务,任务处理函数需要参数
func (cj *CronJobs) AddJobWithParams(jobName string, spec string, jobInterface cron.Job) error {
	if jobName == "" || spec == "" || jobInterface == nil {
		return ErrParam
	}

	if _, ok := cj.getJobID(jobName); ok {
		return nil
	}

	entryId, err := cj.cronHandle.AddJob(spec, jobInterface)
	if err != nil {
		return err
	}

	cj.setJobID(jobName, int(entryId))

	return nil
}

// GetJobs
// 获取当前定时器中的任务
func (cj *CronJobs) GetJobs() []*JobInfo {
	jobInfos := make([]*JobInfo, 0)

	for jobName, entryId := range cj.jobs {
		entry := cj.cronHandle.Entry(cron.EntryID(entryId))
		jobInfo := &JobInfo{
			JobName:  jobName,
			JobId:    string(rune(entry.ID)),
			NextTime: entry.Next.UTC().String(),
			Valid:    entry.Valid(),
		}
		jobInfos = append(jobInfos, jobInfo)
	}
	return jobInfos
}

// StopCron
// 停止定时器
func (cj *CronJobs) StopCron() {
	cj.cronHandle.Stop()
}

// RemoveJob
// 删除任务
func (cj *CronJobs) RemoveJob(jobName string) error {
	jobId, ok := cj.getJobID(jobName)
	if !ok {
		return nil
	}
	cj.cronHandle.Remove(cron.EntryID(jobId))
	cj.deleteJobID(jobName)
	return nil
}

func (cj *CronJobs) Destroy() {
	//删除所有任务
	for jobName, _ := range cj.jobs {
		_ = cj.RemoveJob(jobName)
	}
	//停止定时器
	cj.StopCron()
}