Golang 任务调度实战：用优先级队列避免重要任务被淹没

在很多 Golang 服务中，任务处理一开始往往是“来一个，处理一个”。只要 goroutine 足够多，看起来就能撑住。

但随着业务复杂度提升，问题开始逐渐显现：

• 有些任务非常关键
• 有些任务可以延迟甚至丢弃
• 所有任务却被一视同仁地处理

结果就是：真正重要的任务，反而可能被大量普通任务淹没。

这一篇，我们就从任务调度这个非常贴近业务的场景出发，聊一聊 Golang 项目中优先级队列的实践方式。

一、常见的任务模型：FIFO 队列

很多项目的第一版任务处理模型，通常是一个 channel：

taskCh := make(chan Task, 100)

go func() {
   for task := range taskCh {
      handle(task)
   }
}()

这个模型非常直观：

• 实现简单
• 顺序明确
• 心智负担低

但它隐含了一个默认假设：所有任务的处理价值是相同的。

一旦这个假设不成立，FIFO 就会成为系统瓶颈。

二、为什么任务调度本质上是一个算法问题

当任务具备以下特征之一时，调度就不再只是“并发数量”的问题：

• 不同任务的重要程度不同
• 处理耗时差异较大
• 系统资源有限

这时，系统需要回答一个核心问题：

下一秒，我应该优先处理哪一个任务？

这个问题，本质上就是一个优先级排序问题。

三、优先级队列：比 goroutine 数量更重要的控制手段

优先级队列（Priority Queue）的核心特点很明确：

• 每次取出的，都是“当前优先级最高”的任务
• 插入与取出都有确定规则
• 行为可预测

在 Golang 中，优先级队列通常基于 container/heap 实现。

四、定义一个工程可用的任务模型

任务结构体

type Task struct {
   ID      string
   Priority int // 数值越大，优先级越高
   Index   int // 用于 heap 内部维护
}

五、实现一个优先级队列

完整实现代码

import "container/heap"

// PriorityQueue 实现了 heap.Interface 接口
type PriorityQueue []*Task

func (pq PriorityQueue) Len() int {
   return len(pq)
}

// Less 决定了优先级的排序规则
// 这里我们定义 Priority 越大，优先级越高
func (pq PriorityQueue) Less(i, j int) bool {
   return pq[i].Priority > pq[j].Priority
}

func (pq PriorityQueue) Swap(i, j int) {
   pq[i], pq[j] = pq[j], pq[i]
   pq[i].Index = i
   pq[j].Index = j
}

func (pq *PriorityQueue) Push(x any) {
   task := x.(*Task)
   task.Index = len(*pq)
   *pq = append(*pq, task)
}

func (pq *PriorityQueue) Pop() any {
   old := *pq
   n := len(old)
   task := old[n-1]
   old[n-1] = nil // 避免内存泄漏
   task.Index = -1 // 标记为已移除
   *pq = old[:n-1]
   return task
}

六、在调度器中使用优先级队列

调度逻辑示例

import (
   "container/heap"
   "fmt"
   "time"
)

func main() {
   // 1. 初始化队列
   pq := make(PriorityQueue, 0)
   heap.Init(&pq)

   // 2. 投递任务（模拟不同优先级的任务）
   heap.Push(&pq, &Task{ID: "task-low", Priority: 1})
   heap.Push(&pq, &Task{ID: "task-high", Priority: 10})
   heap.Push(&pq, &Task{ID: "task-medium", Priority: 5})

   // 3. 消费任务
   for pq.Len() > 0 {
      task := heap.Pop(&pq).(*Task)
      fmt.Printf("Processing task: %s (Priority: %d)\n", task.ID, task.Priority)
   }
}

这个调度逻辑的核心优势在于：系统永远在做“当前最重要的事情”。

七、工程中引入优先级调度后，会发生什么变化

1️⃣ 系统行为变得可解释

• 为什么这个任务先执行？
• 因为它的优先级更高

2️⃣ 资源使用更可控

• 高优任务不会被饿死
• 低优任务仍然有机会执行

3️⃣ 更容易做限流与降级

• 低优任务可主动丢弃
• 高优任务优先保障

八、优先级调度中常见的工程陷阱

1️⃣ 优先级设计过于粗糙

• 全是高优
• 等于没有调度

2️⃣ 长时间不调整优先级

• 老任务长期占位
• 新任务得不到执行

3️⃣ 忽略并发安全

container/heap 本身不是并发安全的。在多 goroutine 环境下，必须加锁（如 sync.Mutex）保护 Push/Pop 操作。这涉及到如何处理并发任务写入和消费，是多线程编程的常见挑战。

九、什么时候优先级队列并不适合？

• 任务本身无明显价值差异
• 强顺序要求（必须 FIFO）
• 极低延迟场景（排序本身有开销）

在这些情况下，简单模型反而更稳定。

写在最后

任务调度并不是一个“复杂算法问题”，而是一个系统如何表达业务意图的问题。

当你开始为任务定义优先级，说明你已经在主动控制系统行为，而不是被流量牵着走。这是一个从被动响应到主动设计的思维转变，对于构建健壮的后端服务至关重要。

下一篇，我们将继续聊一个与资源控制密切相关的话题：Golang 项目中的 TopK 与热点统计。

如果你在项目中实现过任务调度，欢迎在 云栈社区 分享你的经验。