Skip to content

Timing Wheels: An In-depth Exploration

Posted on:11 August 2023 at 13:538 min read

Setting Up WSL2: An Extensive Guide

Table of contents

Open Table of contents


The essence of many software systems lies in the precision of their timing. Whether it’s a database handling cache eviction, a networking protocol managing packet retransmissions, or a real-time system coordinating task executions, the capability to manage and execute operations based on time is essential.

Among the myriad of mechanisms devised to address this critical need, timing wheels have emerged as a particularly efficient solution.

This article delves into the heart of timing mechanisms, from basic timer lists to the sophisticated hierarchical timing wheels - we’ll explore their origins, benefits, and practical applications.

History and Origins

Our story begins with the quest for efficient timer management. Traditional mechanisms, while effective for smaller scales, encountered scalability issues as the number of timers grew.

This challenge gave birth to timing wheels - a concept initially introduced in pioneering research papers from institutions like MIT.

As the complexity and scale of our systems advanced, the need for robust timer management solutions grew, leading to the evolution and refinement of timing wheels which have become a cornerstone in high-performance systems design.

A Journey Through Timing Mechanisms

Let’s explore this evolution.

1. Unordered Timer List

2. Ordered Timer List

3. Timer Trees

4. Simple Timing Wheels

5. Hashing Wheel with Ordered Timer Lists

6. Hashing Wheel with Unordered Timer Lists

7. Hierarchical Timing Wheels

What is a Timing Wheel?

Stepping away from the theoretical and diving into the practical, let’s demonstrate the concept of a timing wheel.

Definition and Concept

Imagine a circular buffer, akin to the face of a clock. Each slot on this “clock” represents a time interval, and tasks or events are placed into these slots based on when they need to be executed.

As time progresses, a pointer (or “hand”) rotates around this clock, and when it points to a slot, any tasks within that slot are executed.

Code Example in Go

This Golang snippet provides a rudimentary representation of a timing wheel. It demonstrates how tasks can be inserted and how they are executed when the “tick” function is called.

type TimerTask struct {
    Execute func()

type TimingWheel struct {
    slots []TimerTask
    currentPosition int

func NewTimingWheel(numSlots int) *TimingWheel {
    return &TimingWheel{
        slots: make([]TimerTask, numSlots),
        currentPosition: 0,

func (tw *TimingWheel) Insert(task TimerTask, position int) {
    tw.slots[position] = task

func (tw *TimingWheel) Tick() {
    task := tw.slots[tw.currentPosition]
    tw.currentPosition = (tw.currentPosition + 1) % len(tw.slots)

Advantages of Timing Wheels

Peeling back the layers, let’s delve into what makes timing wheels an effective solution in system design.


Timing wheels excel in scenarios where there are a large number of timers to be managed. Traditional timer data structures, like heaps, may suffer from performance degradation as the number of timers increases. Timing wheels offer a more scalable alternative.

Constant Time Complexity

The insertion and deletion of timers in a timing wheel are typically constant-time operations, which is a significant advantage over other data structures that may require logarithmic or linear time.

Memory Efficiency

Given the fixed size of the timing wheel, memory allocations are predictable and minimal, leading to reduced overhead and better performance.

Applications in System Design and Software Engineering

Diving into real-world applications, let’s explore where timing wheels prove their usefulness.


In the transmision of data packets on a network, timing wheels choreograph events like packet retransmissions in protocols such as TCP. Their efficient timer management ensures seamless communication.

Distributed Systems

In complex domain of distributed systems, where numerous nodes collaborate, timing wheels handle tasks like heartbeat checks, lease renewals, and more. Their precision ensures system consistency and resilience.

Real-time Systems

Precision is the soul of real-time systems. From robotics to media playback, tasks need execution at exact intervals. Timing wheels prove highly effective at this.


Databases, the backbone of many modern applications, rely on timing wheels for functions like cache eviction and garbage collection. This ensures data retrieval remains swift and system health optimal.

Real-World Scenario: Web Server Request Timeouts

Imagine you’re building a web server in Golang. This server interacts with several services, databases, and even external APIs.

To ensure that a slow or unresponsive service doesn’t cause the entire server to hang, you implement request timeouts.

The Problem

You receive thousands of requests per second, each with its own timeout. Managing these timeouts efficiently is crucial to ensure smooth server operations.

The Solution

Implementing a timing wheel to handle these timeouts.

  1. Every incoming request gets a timer set for its timeout duration.
  2. If a request is completed before its timeout, its timer is cancelled.
  3. If the timer expires, the request is terminated, and an appropriate timeout response is sent back.

Implementation in Golang

Let’s draft a basic implementation using a simplified timing wheel:

package main

import (

type Request struct {
	ID      int
	Timeout time.Duration
	Cancel  chan bool

type TimingWheel struct {
	slots          []chan Request
	currentPosition int
	tickDuration   time.Duration

func NewTimingWheel(numSlots int, tickDuration time.Duration) *TimingWheel {
	tw := &TimingWheel{
		slots:          make([]chan Request, numSlots),
		tickDuration:   tickDuration,
		currentPosition: 0,
	for i := range tw.slots {
		tw.slots[i] = make(chan Request, 10) // assuming a buffer size of 10 for each slot
	return tw

func (tw *TimingWheel) Insert(req Request) {
	position := (tw.currentPosition + int(req.Timeout/tw.tickDuration)) % len(tw.slots)
	tw.slots[position] <- req

func (tw *TimingWheel) Start() {
	ticker := time.NewTicker(tw.tickDuration)
	defer ticker.Stop()

	for range ticker.C {
		slot := tw.slots[tw.currentPosition]
		tw.slots[tw.currentPosition] = make(chan Request, 10)

		// Handle expired requests
		for req := range slot {
			select {
			case <-req.Cancel:
				// Request was completed in time
				fmt.Printf("Request %d timed out!\n", req.ID)

		tw.currentPosition = (tw.currentPosition + 1) % len(tw.slots)

func main() {
	tw := NewTimingWheel(60, time.Second) // 60 slots, 1 second per tick

	go tw.Start()

	// Simulating incoming requests
	for i := 0; i < 100; i++ {
		req := Request{
			ID:      i,
			Timeout: time.Duration(5+i%10) * time.Second, // random timeouts between 5 to 15 seconds
			Cancel:  make(chan bool),

	// Simulating some requests completing before timeout
	time.Sleep(8 * time.Second)
	for i := 0; i < 50; i++ {

	// Let the program run for a while
	time.Sleep(2 * time.Minute)

This is a rudimentary implementation to demonstrate the concept. In a real-world scenario, you’d integrate this with your web server’s request handling, ensuring that each request has a timer associated with it in the timing wheel.

The advantage here is the efficiency in handling a large number of timeouts without significant overhead.


As our digital landscapes evolve, transitioning towards real-time and data-intensive ecosystems, the significance of efficient timer management mechanisms cannot be understated. Timing wheels offer a robust solution to this problem, and their applications are widespread.

They are yet another useful tool in the software engineers arsenal, and I hope this article gave you a good introduction to timing wheels and their applications. If you have any questions or feedback, feel free to reach out to me!


  1. ACM: Efficient Timer Management
  2. Confluent: Apache Kafka and Hierarchical Timing Wheels
  3. GitHub: Golang Implementation of Timing Wheel
  4. The Morning Paper: Hashed and Hierarchical Timing Wheels
  5. Image by Steffen L. from Pixabay