Select & Patterns

The select statement lets you wait on multiple channel operations. It's like a switch for channels, enabling powerful concurrent patterns. In this lesson, you'll master select and learn professional concurrency patterns.

The Select Statement

Select waits on multiple channel operations:

Click Run to execute your code

Timeout Pattern

Use select with time.After for timeouts:

Click Run to execute your code

Non-blocking Channel Operations

// Non-blocking receive
select {
case msg := <-ch:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No message")
}

// Non-blocking send
select {
case ch <- msg:
    fmt.Println("Sent message")
default:
    fmt.Println("Channel full")
}

Common Concurrency Patterns

1. Done Channel Pattern

func worker(done <-chan bool) {
    for {
        select {
        case <-done:
            fmt.Println("Worker stopping")
            return
        default:
            // Do work
            fmt.Println("Working...")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    done := make(chan bool)
    go worker(done)
    
    time.Sleep(3 * time.Second)
    done <- true  // Signal worker to stop
    time.Sleep(time.Second)
}

2. Ticker Pattern

func main() {
    ticker := time.NewTicker(500 * time.Millisecond)
    done := make(chan bool)
    
    go func() {
        for {
            select {
            case <-done:
                return
            case t := <-ticker.C:
                fmt.Println("Tick at", t)
            }
        }
    }()
    
    time.Sleep(2 * time.Second)
    ticker.Stop()
    done <- true
}

3. Context Pattern

Click Run to execute your code

Common Mistakes

// ❌ Wrong - blocks if channel not ready
select {
case msg := <-ch:
    fmt.Println(msg)
}

// ✅ Correct - non-blocking
select {
case msg := <-ch:
    fmt.Println(msg)
default:
    fmt.Println("No message")
}

// ❌ Wrong - done channel ignored in loop
for {
    select {
    case msg := <-messages:
        fmt.Println(msg)
    }
    // done channel never checked!
}

// ✅ Correct - check done channel
for {
    select {
    case <-done:
        return
    case msg := <-messages:
        fmt.Println(msg)
    }
}

Exercise: Rate Limiter

package main

import (
    "fmt"
    "time"
)

func main() {
    requests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        requests <- i
    }
    close(requests)
    
    // Rate limiter: 1 request per second
    limiter := time.NewTicker(time.Second)
    defer limiter.Stop()
    
    fmt.Println("Rate Limiter: Processing requests...")
    fmt.Println("====================================")
    
    for req := range requests {
        <-limiter.C  // Wait for tick
        fmt.Printf("Request %d processed at %s\n", req, time.Now().Format("15:04:05"))
    }
    
    fmt.Println("====================================")
    fmt.Println("All requests processed!")
}

Summary

What's Next?

Congratulations on completing the Concurrency module! You've mastered goroutines, channels, and select—Go's most powerful features. Next, you'll explore Packages & Standard Library to build real-world applications!