golang使用简单流畅语法调度周期性任务插件库clockwerk的使用

Golang使用简单流畅语法调度周期性任务插件库clockwerk的使用

简介

clockwerk是一个Golang作业调度库，允许您使用简单流畅的语法来调度周期性任务。

安装

使用go get安装最新版本的库：

go get -u github.com/onatm/clockwerk@latest

使用

在您的应用中引入clockwerk：

import "github.com/onatm/clockwerk"

示例

下面是一个完整的示例demo，展示如何使用clockwerk来调度周期性任务：

package main

import (
  "fmt"
  "time"
  "github.com/onatm/clockwerk"
)

// 定义一个任务结构体
type DummyJob struct{}

// 实现Run方法，这是任务执行的内容
func (d DummyJob) Run() {
  fmt.Println("Every 30 seconds")
}

func main() {
  var job DummyJob
  
  // 创建一个新的调度器
  c := clockwerk.New()
  
  // 设置每30秒执行一次job任务
  c.Every(30 * time.Second).Do(job)
  
  // 启动调度器
  c.Start()
  
  // 保持程序运行
  select {}
}

这个示例中：

  1. 我们定义了一个DummyJob结构体并实现了Run()方法
  2. 创建了一个新的clockwerk调度器实例
  3. 使用流畅的语法设置了每30秒执行一次任务
  4. 调用Start()方法启动调度器

clockwerk提供了简单直观的API来调度周期性任务，非常适合需要定时执行任务的Golang应用场景。


更多关于golang使用简单流畅语法调度周期性任务插件库clockwerk的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang使用简单流畅语法调度周期性任务插件库clockwerk的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang 使用 Clockwerk 调度周期性任务

Clockwerk 是一个轻量级的 Golang 周期性任务调度库，它提供了简单流畅的 API 来安排周期性任务的执行。下面我将详细介绍如何使用 Clockwerk。

安装 Clockwerk

首先使用 go get 安装 Clockwerk：

go get github.com/onatm/clockwerk

基本用法

package main

import (
	"fmt"
	"time"

	"github.com/onatm/clockwerk"
)

// 定义一个任务结构体
type MyJob struct{}

// 实现 Job 接口的 Run 方法
func (j MyJob) Run() {
	fmt.Println("任务执行:", time.Now().Format("2006-01-02 15:04:05"))
}

func main() {
	var job MyJob
	
	// 创建调度器
	c := clockwerk.New()
	
	// 安排任务每5秒执行一次
	c.Every(5 * time.Second).Do(job)
	
	// 开始调度
	c.Start()
	
	// 主程序保持运行
	select {}
}

高级特性

1. 多种时间间隔设置

// 每分钟执行
c.Every(1 * time.Minute).Do(job)

// 每小时执行
c.Every(1 * time.Hour).Do(job)

// 每天10:30执行
c.Every(1 * time.Day).At("10:30").Do(job)

2. 延迟首次执行

// 5秒后首次执行，之后每10秒执行一次
c.Every(10 * time.Second).NotImmediately().Do(job)

3. 停止任务

// 创建任务并获取引用
task := c.Every(5 * time.Second).Do(job)

// 停止特定任务
task.Stop()

// 停止所有任务
c.Stop()

4. 带参数的任务

type ParamJob struct {
	Name string
}

func (j ParamJob) Run() {
	fmt.Printf("任务 %s 执行: %s\n", j.Name, time.Now().Format("15:04:05"))
}

func main() {
	job1 := ParamJob{Name: "Job1"}
	job2 := ParamJob{Name: "Job2"}
	
	c := clockwerk.New()
	c.Every(3 * time.Second).Do(job1)
	c.Every(5 * time.Second).Do(job2)
	
	c.Start()
	select {}
}

完整示例

package main

import (
	"fmt"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/onatm/clockwerk"
)

type DatabaseBackupJob struct {
	DBName string
}

func (j DatabaseBackupJob) Run() {
	fmt.Printf("[%s] 开始备份数据库 %s...\n", 
		time.Now().Format("2006-01-02 15:04:05"), j.DBName)
	// 模拟备份操作
	time.Sleep(2 * time.Second)
	fmt.Printf("[%s] 数据库 %s 备份完成\n",
		time.Now().Format("2006-01-02 15:04:05"), j.DBName)
}

func main() {
	// 创建两个备份任务
	backupJob1 := DatabaseBackupJob{DBName: "user_db"}
	backupJob2 := DatabaseBackupJob{DBName: "order_db"}
	
	// 初始化调度器
	scheduler := clockwerk.New()
	
	// 安排任务
	// 每天凌晨1点备份user_db
	scheduler.Every(1 * time.Day).At("01:00").Do(backupJob1)
	
	// 每30分钟备份order_db
	scheduler.Every(30 * time.Minute).Do(backupJob2)
	
	// 优雅退出处理
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	
	go func() {
		<-sigs
		fmt.Println("\n接收到终止信号，停止调度器...")
		scheduler.Stop()
		os.Exit(0)
	}()
	
	fmt.Println("启动定时任务调度器...")
	scheduler.Start()
	
	// 保持主程序运行
	select {}
}

注意事项

  1. Clockwerk 不是分布式任务调度器，适合单机应用
  2. 如果任务执行时间超过间隔时间，下一次执行会等待当前任务完成
  3. 对于高精度定时需求(毫秒级)，Clockwerk 可能不是最佳选择
  4. 任务中的 panic 会被捕获并打印错误日志，但不会影响调度器运行

Clockwerk 提供了简单直观的 API 来管理周期性任务，非常适合中小型 Go 应用的定时任务需求。

回到顶部