Implementation of Timers and Scheduled Tasks in Go

Description
The timer mechanism in the Go language is a crucial part of concurrent programming, used to execute code after specific time intervals or perform tasks periodically. It primarily involves the Timer and Ticker types from the time package, as well as underlying implementations like the timing wheel at the runtime level.

Detailed Knowledge Points

1. Basic Timer Types

• Timer: A one-shot timer that triggers once after a specified duration.
• Ticker: A periodic timer that triggers repeatedly at fixed time intervals.

2. Creating and Using Timers

// Method 1: NewTimer
timer1 := time.NewTimer(2 * time.Second)
<-timer1.C  // Block and wait for 2 seconds

// Method 2: After (a more concise syntactic sugar)
<-time.After(1 * time.Second)

// Method 3: AfterFunc (asynchronous execution)
time.AfterFunc(3*time.Second, func() {
    fmt.Println("Executed after 3 seconds")
})

3. Timer Lifecycle Management

timer := time.NewTimer(5 * time.Second)
go func() {
    <-timer.C
    fmt.Println("Timer triggered")
}()

// Can stop the timer midway
if timer.Stop() {
    fmt.Println("Timer stopped")
}

// Reset the timer (must be done after stopping or triggering)
timer.Reset(3 * time.Second)

4. Periodic Tasks with Ticker

ticker := time.NewTicker(1 * time.Second)
defer ticker.Stop()  // Important: prevents goroutine leaks

for {
    select {
    case <-ticker.C:
        fmt.Println("Executed every second")
    case <-done:  // External control to exit
        return
    }
}

5. Underlying Implementation Principles

Time Wheel Algorithm

• Go uses a four-level time wheel to manage timers.
• Levels: 64-bit mask divided into 4 levels (8bit × 4)
  • First level: Handles 2^8=256 slots (0-255)
  • Second level: Handles 256×256=65536 slots
  • And so on, covering the entire time range
• Advantage: O(1) time complexity for adding/deleting timers.

runtime.timer Structure

type timer struct {
    tb *timersBucket  // Associated time bucket
    i  int            // Index in the heap
    
    when   int64      // Trigger time (nanoseconds)
    period int64      // Period (for Ticker)
    f      func(interface{}, uintptr)  // Callback function
}

6. Performance Optimization Practices

Avoid Creating Timers in Loops

// Wrong approach: Creating a new Timer each loop
for {
    select {
    case <-time.After(1 * time.Second):
        // Creates a new object each time
    }
}

// Correct approach: Reuse the Timer
timer := time.NewTimer(1 * time.Second)
defer timer.Stop()

for {
    timer.Reset(1 * time.Second)  // Reset and reuse
    select {
    case <-timer.C:
        // Processing logic
    }
}

7. High-Precision Timing Scenarios

// Using time.Tick but beware of goroutine leak risks
ticker := time.NewTicker(100 * time.Millisecond)
defer ticker.Stop()

for t := range ticker.C {  // Triggers every 100 milliseconds
    fmt.Printf("Precise time: %v\n", t)
}

// Use a time.Sleep loop for even higher precision
for {
    start := time.Now()
    // Execute task
    elapsed := time.Since(start)
    time.Sleep(100*time.Millisecond - elapsed)
}

8. Practical Application Scenarios

Timeout Control

func withTimeout() error {
    select {
    case result := <-asyncOperation():
        return result
    case <-time.After(5 * time.Second):
        return errors.New("Operation timeout")
    }
}

Summary
Go's timer mechanism combines user-friendly APIs with an efficient time wheel algorithm implementation. Understanding its underlying principles helps avoid common pitfalls (such as goroutine leaks) and supports making correct technical choices in high-concurrency scenarios.