go-zero 框架通过内置的 core/stas 包中的 taskgroup 实现单机定时任务,而分布式调度则依赖外部协调器(如 etcd)或第三方库(如 cron + etcd)来保证全局唯一性。具体做法是:在微服务中启动一个后台协程组,注册需要定期执行的业务逻辑;对于分布式场景,利用 etcd 的租约(lease)和键值竞争机制,确保同一时刻只有一个节点获取到锁并执行任务,其他节点自动跳过。

如何配置单机定时任务的执行周期与并发控制?
单机定时任务的核心在于使用 stas.TaskGroup 管理生命周期,并通过 WithTimeout 防止任务阻塞主流程。开发者需定义一个包含所有定时任务的切片,每个任务由名称、间隔时间和执行函数组成。框架会自动处理协程的优雅关闭和异常捕获。若任务执行时间超过设定阈值,可配置超时回调以避免资源泄漏。

package main
import (
"context"
"fmt"
"time"
"github.com/zeromicro/go-zero/core/stas"
)
func main() {
// 创建 TaskGroup,设置最大并发数为 1,防止重复执行
tg := stas.NewTaskGroup(stas.WithMaxConcurrent(1))
// 定义任务:每 5 秒执行一次
task := stas.Task{
Name: "sync-data",
Period: 5 * time.Second,
Func: func(ctx context.Context) {
fmt.Println("Executing sync-data at", time.Now())
// 模拟业务逻辑
},
}
// 启动任务组
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
if err := tg.Start(ctx, task); err != nil {
panic(err)
}
// 保持主进程运行
select {}
}
上述代码展示了如何创建一个名为 sync-data 的任务,它每 5 秒执行一次。通过 WithMaxConcurrent(1) 参数,确保了即使前一次任务未结束,下一次也不会启动,从而避免并发冲突。程序输出会每隔 5 秒打印当前时间戳,直到主上下文被取消。
如何在多节点环境下实现分布式锁定的唯一执行?
分布式调度的关键在于“互斥”。Go-Zero 本身不提供原生的分布式锁,但通常结合 etcd 实现。核心思路是:每个节点尝试在 etcd 中创建一个带租约的键(Key),只有成功创建的节点才有权执行任务。如果节点宕机,租约过期,键自动删除,其他节点即可接管。这种机制保证了高可用性和故障转移。

package main
import (
"context"
"fmt"
"time"
"go.etcd.io/etcd/client/v3"
"github.com/zeromicro/go-zero/core/logx"
)
var leaseID client.LeaseID
func runDistributedTask(client *clientv3.Client, key string, duration time.Duration) {
for {
// 1. 获取租约
leaseResp, err := client.Grant(context.Background(), int64(duration.Seconds()+10))
if err != nil {
logx.Error(err)
time.Sleep(time.Second)
continue
}
leaseID = leaseResp.ID
// 2. 尝试设置键,使用 PrevKV 确保原子性
putCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
resp, err := client.Put(putCtx, key, "running", clientv3.WithLease(leaseID))
cancel()
if err != nil {
logx.Error(err)
time.Sleep(time.Second)
continue
}
// 3. 检查是否成功获取锁(Rev > 0 表示写入成功)
if resp.Header.Revision > 0 {
fmt.Println("Node acquired lock, executing task...")
// 执行实际业务逻辑
executeBusinessLogic()
// 4. 保持心跳,续期租约
keepAlive(leaseID, client)
} else {
// 获取失败,说明有其他节点持有锁,释放当前租约
client.Revoke(context.Background(), leaseID)
time.Sleep(time.Second) // 等待重试
}
}
}
func keepAlive(id client.LeaseID, client *clientv3.Client) {
kaChan, err := client.KeepAlive(context.Background(), id)
if err != nil {
return
}
go func() {
for {
select {
case ka := <-kaChan:
if ka == nil {
return
}
}
}
}()
}
func executeBusinessLogic() {
fmt.Println("Business logic executed successfully.")
}
该示例演示了基于 etcd 的分布式任务执行流程。首先,节点申请一个租约,然后尝试向 etcd 写入一个带有该租约的键。如果写入成功(即返回的 Revision 大于 0),则该节点获得执行权,并开始执行业务逻辑同时维持心跳。如果写入失败,说明锁已被其他节点持有,当前节点将撤销租约并进入休眠等待下一轮竞争。这种方式有效避免了多节点重复执行同一任务的问题。
当任务执行时间超过预期时,系统如何处理状态一致性?
在分布式场景中,如果任务执行时间超过了 etcd 租约的 TTL(Time To Live),会导致键自动过期并被删除,从而触发其他节点重新竞争锁。这可能导致正在执行的任务被中断或重复执行。为解决此问题,应在任务开始前动态延长租约,或在任务完成后显式释放锁。此外,可以在业务层增加幂等性检查,确保即使任务被重复触发,也不会产生副作用。例如,在处理订单同步时,可以记录最后同步的时间戳,仅处理新增数据。


















