Day 2: Concurrency Patterns & Context

1. Learn: Advanced Concurrency

Building on Day 1, we explore patterns to manage multiple goroutines.

• Select Statement: Like a switch for channels. It blocks until one of its cases can run. Essential for handling timeouts and multiple data streams.
• Buffered Channels: Allow sending values without blocking until the buffer is full. Useful for decoupling producers and consumers.
• Context Package: The standard way to handle cancellation, deadlines, and request-scoped values across API boundaries.

2. Practice: Fan-Out / Fan-In with Context

Implement a pipeline that fans out work to multiple goroutines and fans results back in, with cancellation support.

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func worker(ctx context.Context, id int, jobs <-chan int, results chan<- int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("Worker %d stopping\n", id)
            return
        case j, ok := <-jobs:
            if !ok {
                return
            }
            fmt.Printf("Worker %d processing %d\n", id, j)
            time.Sleep(500 * time.Millisecond)
            results <- j * j
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    jobs := make(chan int, 10)
    results := make(chan int, 10)

    // Fan-Out
    for w := 1; w <= 3; w++ {
        go worker(ctx, w, jobs, results)
    }

    // Send jobs
    go func() {
        for j := 1; j <= 10; j++ {
            jobs <- j
        }
        close(jobs)
    }()

    // Fan-In (simplified for demo)
    // In production, use a separate goroutine + WaitGroup to close results
    for i := 0; i < 10; i++ {
        select {
        case res := <-results:
            fmt.Println("Result:", res)
        case <-ctx.Done():
            fmt.Println("Main: Context timeout!")
            return
        }
    }
}

3. Interview Questions

4. Assessment

Progress Log