用 Go 实现一个轻量级并发任务调度器(支持限速)

前言

在日常开发中,我们经常会遇到这样的场景:

  • • 有一堆任务要跑(比如:发请求、处理数据、爬虫等)
  • • 不希望一次性全部跑完,担心打爆服务端或者被封
  • • 想要设置并发数、限速,还能控制任务重试、失败记录

那么,能不能用 Go 实现一个"轻量级的并发任务调度器"?------答案是:当然可以!

今天我们就来用 Go 从零实现一个可配置的任务调度器,支持:

  • • 最大并发数控制(worker pool)
  • • 每秒请求速率限制(rate limit)
  • • 简单的失败重试机制
  • • 支持结果收集与错误输出

效果展示

你可以像这样调用我们的调度器:

go 复制代码
scheduler := NewScheduler(5, 10) // 并发 5,速率限制每秒 10 次

for i := 0; i < 100; i++ {
    task := NewTask(func() error {
        // 模拟网络请求或业务逻辑
        fmt.Println("正在处理任务:", i)
        time.Sleep(300 * time.Millisecond)
        return nil
    })
    scheduler.Submit(task)
}

scheduler.Wait()
fmt.Println("全部任务完成")

核心组件设计

1. 任务(Task)

我们将每个任务抽象为一个结构体:

go 复制代码
type Task struct {
    fn   func() error
    retry int
}

2. 调度器(Scheduler)

负责维护任务队列、worker、速率限制器:

go 复制代码
type Scheduler struct {
    tasks       chan *Task
    wg          sync.WaitGroup
    rateLimiter <-chan time.Time
}

实现代码

下面是完整实现(可以直接复制使用):

go 复制代码
type Task struct {
    fn    func() error
    retry int
}

func NewTask(fn func() error) *Task {
    return &Task{fn: fn, retry: 3}
}

type Scheduler struct {
    tasks       chan *Task
    wg          sync.WaitGroup
    rateLimiter <-chan time.Time
}

func NewScheduler(concurrency int, ratePerSecond int) *Scheduler {
    s := &Scheduler{
        tasks:       make(chan *Task, 100),
        rateLimiter: time.Tick(time.Second / time.Duration(ratePerSecond)),
    }

    for i := 0; i < concurrency; i++ {
        go s.worker()
    }

    return s
}

func (s *Scheduler) Submit(task *Task) {
    s.wg.Add(1)
    s.tasks <- task
}

func (s *Scheduler) worker() {
    for task := range s.tasks {
        <-s.rateLimiter // 限速

        err := task.fn()
        if err != nil && task.retry > 0 {
            fmt.Println("任务失败,重试中...")
            task.retry--
            s.Submit(task)
        } else if err != nil {
            fmt.Println("任务最终失败:", err)
        }

        s.wg.Done()
    }
}

func (s *Scheduler) Wait() {
    s.wg.Wait()
    close(s.tasks)
}

实战应用场景

  • • 网络爬虫限速抓取
  • • 批量发送邮件/SMS/请求,防止接口限流
  • • 云服务任务调度、批量自动化操作
  • • 异步数据采集和聚合

总结

Go 的并发模型非常适合处理"海量任务 + 控制速率 + 错误重试"的需求。本篇实现的调度器非常轻量,适合作为基础组件集成到你自己的系统中。

如果你有更多需求,比如:

  • • 增加失败回调
  • • 支持超时控制
  • • 任务优先级
  • • 后台监控 dashboard

欢迎留言交流,我们可以继续升级这个任务调度器!


关注我,带你用 Go 写出更有趣的小工具!

如果你觉得这篇文章对你有帮助,别忘了点赞、收藏、转发哈~

相关推荐
YuTaoShao39 分钟前
【LeetCode 热题 100】56. 合并区间——排序+遍历
java·算法·leetcode·职场和发展
程序员张342 分钟前
SpringBoot计时一次请求耗时
java·spring boot·后端
二进制person5 小时前
Java SE--方法的使用
java·开发语言·算法
OneQ6665 小时前
C++讲解---创建日期类
开发语言·c++·算法
JoJo_Way5 小时前
LeetCode三数之和-js题解
javascript·算法·leetcode
.30-06Springfield6 小时前
人工智能概念之七:集成学习思想(Bagging、Boosting、Stacking)
人工智能·算法·机器学习·集成学习
程序员岳焱7 小时前
Java 与 MySQL 性能优化:Java 实现百万数据分批次插入的最佳实践
后端·mysql·性能优化
麦兜*7 小时前
Spring Boot启动优化7板斧(延迟初始化、组件扫描精准打击、JVM参数调优):砍掉70%启动时间的魔鬼实践
java·jvm·spring boot·后端·spring·spring cloud·系统架构
大只鹅8 小时前
解决 Spring Boot 对 Elasticsearch 字段没有小驼峰映射的问题
spring boot·后端·elasticsearch
凌肖战8 小时前
力扣网C语言编程题:在数组中查找目标值位置之二分查找法
c语言·算法·leetcode