Go语言实现定时任务速查手册

定时任务几乎是每个后端应用的标配，Go语言里实现起来其实有不少门道。从最简单的延迟执行，到复杂的Cron表达式调度，再到高并发的场景，下面整理了几个关键场景的实战方案，直接上代码。

问题1：如何实现一个简单的延迟任务？

最简单的方式就是用 time.After，一行代码搞定延迟。下面这个例子让程序在5秒后打印一段话。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 设置延迟时间
	delay := 5 * time.Second

	// 使用 time.After 实现延迟
	<-time.After(delay)
	fmt.Println("5秒后执行的任务")
}

问题2：如何实现一个周期性任务？

周期任务用 time.Ticker 最直接。创建一个Ticker，它会每隔指定时间往通道里发信号，循环读取即可。

package main

import (
	"fmt"
	"time"
)

func main() {
	// 创建一个每2秒触发的 Ticker
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	// 无限循环，每次 Ticker 触发时执行任务
	for range ticker.C {
		fmt.Println("每2秒执行的任务")
	}
}

问题3：如何优雅地停止一个周期性任务？

直接退出循环不够优雅，推荐结合 context 的取消机制。创建一个可取消的Context，在select中监听取消信号，就能安全地停止任务。

package main

import (
	"context"
	"fmt"
	"time"
)

func main() {
	// 创建一个带取消功能的 Context
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// 创建一个每2秒触发的 Ticker
	ticker := time.NewTicker(2 * time.Second)
	defer ticker.Stop()

	// 启动一个 goroutine 执行周期任务
	go func() {
		for {
			select {
			case <-ticker.C:
				fmt.Println("每2秒执行的任务")
			case <-ctx.Done():
				fmt.Println("任务已取消")
				return
			}
		}
	}()

	// 模拟运行一段时间后取消任务
	time.Sleep(10 * time.Second)
	cancel()
}

问题4：如何实现多个任务并行执行？

多个周期任务同时跑，用 sync.WaitGroup 配合context来统一控制。每个任务启动一个goroutine，主程序用WaitGroup等待全部完成。

package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

func main() {
	// 创建一个带取消功能的 Context
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	// 创建一个 WaitGroup 用于等待所有任务完成
	var wg sync.WaitGroup

	// 定义一个执行任务的函数
	runTask := func(duration time.Duration, taskName string) {
		defer wg.Done()
		ticker := time.NewTicker(duration)
		defer ticker.Stop()

		for {
			select {
			case <-ticker.C:
				fmt.Printf("执行 %s 任务\n", taskName)
			case <-ctx.Done():
				fmt.Printf("%s 任务已取消\n", taskName)
				return
			}
		}
	}

	// 启动多个任务
	wg.Add(2)
	go runTask(2*time.Second, "任务1")
	go runTask(3*time.Second, "任务2")

	// 模拟运行一段时间后取消任务
	time.Sleep(15 * time.Second)
	cancel()

	// 等待所有任务完成
	wg.Wait()
}

问题5：如何使用第三方库实现更复杂的定时任务？

如果要做复杂调度（比如每周五下午5点执行），标准库就不够用了。社区里最常用的是 robfig/cron，它支持Cron表达式，用法简洁。

package main

import (
	"fmt"
	"github.com/robfig/cron/v3"
)

func main() {
	// 创建一个新的 Cron 实例
	c := cron.New()

	// 添加一个每分钟执行的任务
	_, err := c.AddFunc("@every 1m", func() {
		fmt.Println("每分钟执行的任务")
	})
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 添加一个每周五下午 5 点执行的任务
	_, err = c.AddFunc("0 17 * * 5", func() {
		fmt.Println("每周五下午5点执行的任务")
	})
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 启动 Cron
	c.Start()

	// 模拟运行一段时间
	select {
	case <-time.After(20 * time.Second):
		fmt.Println("停止 Cron")
		c.Stop()
	}
}

问题6：如何处理定时任务的错误？

任务执行中可能panic，比如调用了外部服务超时。cron库本身不帮你 recover，需要在任务内部用 defer+recover 兜底。下面这个例子模拟了panic场景。

package main

import (
	"fmt"
	"github.com/robfig/cron/v3"
)

func main() {
	// 创建一个新的 Cron 实例
	c := cron.New()

	// 定义一个可能会出错的任务
	task := func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Println("任务出错:", r)
			}
		}()
		fmt.Println("执行任务")
		// 模拟任务出错
		panic("模拟错误")
	}

	// 添加任务并处理错误
	_, err := c.AddFunc("@every 5s", task)
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 启动 Cron
	c.Start()

	// 模拟运行一段时间
	select {
	case <-time.After(20 * time.Second):
		fmt.Println("停止 Cron")
		c.Stop()
	}
}

问题7：如何在定时任务中使用数据库或其他外部资源？

在定时任务里操作数据库，要特别注意连接池管理和并发安全。每个任务执行时使用独立的连接，别忘了defer关闭。下面是用cron任务定时查询数据库的典型写法。

package main

import (
	"database/sql"
	"fmt"
	"time"

	_ "github.com/go-sql-driver/mysql"
	"github.com/robfig/cron/v3"
)

func main() {
	// 打开数据库连接
	db, err := sql.Open("mysql", "user:password@tcp(127.0.0.1:3306)/dbname")
	if err != nil {
		fmt.Println("数据库连接失败:", err)
		return
	}
	defer db.Close()

	// 创建一个新的 Cron 实例
	c := cron.New()

	// 定义一个任务，该任务会查询数据库
	task := func() {
		rows, err := db.Query("SELECT * FROM tasks")
		if err != nil {
			fmt.Println("查询数据库失败:", err)
			return
		}
		defer rows.Close()

		for rows.Next() {
			var id int
			var name string
			if err := rows.Scan(&id, &name); err != nil {
				fmt.Println("扫描数据库行失败:", err)
				continue
			}
			fmt.Printf("任务 ID: %d, 名称: %s\n", id, name)
		}
	}

	// 添加任务
	_, err = c.AddFunc("@every 10s", task)
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 启动 Cron
	c.Start()

	// 模拟运行一段时间
	select {
	case <-time.After(30 * time.Second):
		fmt.Println("停止 Cron")
		c.Stop()
	}
}

问题8：如何动态添加或删除定时任务？

运行时动态管理任务也是常见需求。cron库提供了 Entries() 和 Remove() 方法，可以随时增删。下面演示了启动后添加一个任务，10秒后再删除它。

package main

import (
	"fmt"
	"github.com/robfig/cron/v3"
	"time"
)

func main() {
	// 创建一个新的 Cron 实例
	c := cron.New()

	// 启动 Cron
	c.Start()

	// 定义一个任务
	task := func() {
		fmt.Println("执行任务")
	}

	// 动态添加任务
	_, err := c.AddFunc("@every 5s", task)
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 模拟运行一段时间
	time.Sleep(10 * time.Second)

	// 动态删除任务
	entries := c.Entries()
	if len(entries) > 0 {
		c.Remove(entries[0].ID)
		fmt.Println("删除任务")
	}

	// 再次模拟运行一段时间
	time.Sleep(10 * time.Second)

	// 停止 Cron
	c.Stop()
}

问题9：如何避免定时任务的重叠执行？

如果任务执行时间比周期还长，就会发生重叠。最简单的防重叠手段是加互斥锁，任务开始时尝试获取锁，拿不到就直接跳过。下面的例子中任务执行需要4秒，但周期只有3秒，用Mutex保证不会并发执行。

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/robfig/cron/v3"
)

func main() {
	// 创建一个新的 Cron 实例
	c := cron.New()

	// 创建一个互斥锁
	var mutex sync.Mutex

	// 定义一个任务，该任务会获取互斥锁
	task := func() {
		// 尝试获取锁
		mutex.Lock()
		defer mutex.Unlock()

		fmt.Println("执行任务")
		// 模拟长时间执行的任务
		time.Sleep(4 * time.Second)
	}

	// 添加任务
	_, err := c.AddFunc("@every 3s", task)
	if err != nil {
		fmt.Println("添加任务失败:", err)
		return
	}

	// 启动 Cron
	c.Start()

	// 模拟运行一段时间
	select {
	case <-time.After(20 * time.Second):
		fmt.Println("停止 Cron")
		c.Stop()
	}
}

问题10：如何使用时间轮（Time Wheel）实现高并发定时任务？

当任务数量极大（比如百万级）且对延迟敏感时，传统Ticker或Cron可能成为瓶颈。时间轮算法是更优的选择，它能将时间复杂度降到O(1)。下面是用 time wheels 库（注：实际github仓库名可能不同，但概念一致）实现的示例：创建时间轮，批量添加多个定时任务。

package main

import (
	"fmt"
	"time"

	"github.com/robfig/cron/v3"
	"github.com/insolar/time wheels"
)

func main() {
	// 创建一个新的时间轮实例
	wheel := time wheels.NewTimeWheel(10*time.Second, 100)

	// 启动时间轮
	go wheel.Start()

	// 定义一个任务
	task := func() {
		fmt.Println("执行任务")
	}

	// 添加多个任务
	for i := 0; i < 10; i++ {
		wheel.Add(time.Now().Add(time.Duration(i+1)*time.Second), task)
	}

	// 模拟运行一段时间
	select {
	case <-time.After(20 * time.Second):
		fmt.Println("停止时间轮")
		wheel.Stop()
	}
}