Golang模拟实现任务调度状态检测

package runner

import (
	"errors"
	"os"
	"os/signal"
	"time"
)

// runner包用于展示如何通过通道监视程序的执行时间, 如果程序运行时间太长
// 也可以用runner包来终止程序。当开发需要调度后台处理任务的程序时，这种模式会很有用。
// 这个程序可能会作为cron作业执行, 或者基于定时任务的云环境里执行

type Runner struct {
	// interrupt通道报告从操作系统发送的信号
	interrupt chan os.Signal

	// complete通道报告处理任务已经完成
	complete chan error

	// timeout 报告处理任务已经超时
	timeout <-chan time.Time

	// tasks持有一组以索引顺序依次执行的函数
	tasks 	[]func(int)
}

// ErrTimeout会在任务执行超时时返回
var ErrTimeout = errors.New("received timeout")

// ErrInterrupt会在接收到操作系统的事件时返回
var ErrInterrupt = errors.New("received interrupt")

// New返回一个新的准备使用的Runner
func New(d time.Duration) *Runner {
	return &Runner{
		interrupt: make(chan os.Signal, 1),
		complete:  make(chan error),
		timeout:   time.After(d),
	}
}

// Add将一个任务附加到Runner上。这个任务是一个
// 接受一个int类型的ID作为参数的函数
func (r *Runner) Add(tasks ...func(int)) {
	r.tasks = append(r.tasks, tasks...)
}

// Start执行所有任务, 并监视通道事件
func (r *Runner) Start() error {
	// 我们希望接收所有中断信号
	signal.Notify(r.interrupt, os.Interrupt)

	// 启动一个goroutine执行任务数组
	go func() {
		r.complete <- r.run()
	}()

	select {
	// 当任务完成时发出的信号
	case err := <-r.complete:
		return err
	// 当任务处理超时时发出的信号
	case <-r.timeout:
		return ErrTimeout
	}
}

// run执行每一个已注册的任务
func (r *Runner) run() error {
	for id, task := range r.tasks {
		// 检测操作系统的中断信号
		if r.gotInterrupt() {
			return ErrInterrupt
		}
		// 执行已注册的任务
		task(id)
	}
	return nil
}

// 验证是否接收到了中断信号
func (r *Runner) gotInterrupt() bool {
	select {
	    // 当中断事件被触发时发出的信号
		case <-r.interrupt:
			// 停止接收后续的任何信号
			signal.Stop(r.interrupt)
			return true
		//	继续正常运行
		default:
			return false
	}
}

package main

import (
	"GoPratice/runner"
	"log"
	"os"
	"time"
)

// 这个示例程序演示如何使用通道来监视
// 程序运行的事件, 以及在程序运行时间过长时如何终止程序

// timeout规定了必须在多少秒内完成处理
const timeout = 10 * time.Second

func init() {
	log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}

func main() {
	log.Println("Starting work.")

	// 本次执行分配超时时间
	r := runner.New(timeout)

	// 加入要执行的任务
	r.Add(createTask(), createTask(), createTask())

	// 执行任务并处理结果
	if err := r.Start(); err != nil {
		switch err {
		case runner.ErrTimeout:
			log.Println("Termination due to timeout")
			os.Exit(1)
		case runner.ErrInterrupt:
			log.Println("Termination due to interrupt")
			os.Exit(2)
		}
	}

	log.Println("Process ended.")
}

func createTask() func(int) {
	return func(id int) {
		log.Println("Processor - Task #%d.", id)
		time.Sleep(time.Duration(id) * time.Second)
	}
}