Mastering Task Prioritization in Go: Build a Robust Priority Queue

Common Task Model: FIFO Queue

Many Go services start with a simple channel‑based queue where a goroutine reads from a channel and processes each task. This model assumes all tasks have equal value, which becomes a bottleneck when tasks differ in importance.

taskCh := make(chan Task, 100)
go func() {
    for task := range taskCh {
        handle(task)
    }
}()

Why Scheduling Is an Algorithm Problem

When tasks have different priorities, execution times, or resource consumption, the system must decide which task to run next. This is a priority‑ordering problem.

Which task should be processed next?

Priority Queue as the Control Mechanism

Go’s container/heap package can be used to implement a priority queue that always extracts the highest‑priority item.

Task Model

type Task struct {
    ID       string // unique identifier
    Priority int    // larger value means higher priority
    Index    int    // internal heap index
}

Priority Queue Implementation

The queue implements heap.Interface:

type PriorityQueue []*Task

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

func (pq PriorityQueue) Less(i, j int) bool {
    // higher Priority value = higher priority
    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 // avoid memory leak
    task.Index = -1 // mark as removed
    *pq = old[:n-1]
    return task
}

Using the Priority Queue in a Scheduler

import (
    "container/heap"
    "fmt"
)

func main() {
    // 1. Initialize the queue
    pq := make(PriorityQueue, 0)
    heap.Init(&pq)

    // 2. Push tasks with different priorities
    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. Consume tasks in priority order
    for pq.Len() > 0 {
        task := heap.Pop(&pq).(*Task)
        fmt.Printf("Processing task: %s (Priority: %d)
", task.ID, task.Priority)
    }
}

Effects of Introducing Priority Scheduling

Explainable System Behavior

The order of execution is directly tied to the task’s priority.

Controllable Resource Usage

High‑priority tasks are less likely to starve.

Low‑priority tasks still receive CPU time.

Simplified Throttling and Degradation

Low‑priority work can be dropped proactively.

Critical work is guaranteed service.

Common Engineering Pitfalls

Overly Coarse Priority Design

Marking all tasks as high priority eliminates the benefit of scheduling.

Stale Priorities

Long‑lived tasks may occupy slots indefinitely, preventing newer work.

Concurrency Safety

The container/heap implementation is not thread‑safe. In a multi‑goroutine environment protect Push and Pop with a sync.Mutex or other synchronization primitive.

When a Priority Queue Is Not Suitable

Tasks have no clear value difference.

Strict FIFO order is required.

Ultra‑low‑latency scenarios where sorting overhead outweighs benefits.

Conclusion

Task scheduling is less about complex algorithms and more about expressing business intent. Defining explicit priorities lets the system actively control which work is performed first.