Go Goroutines Tutorial

Goroutines are the fundamental building blocks of concurrent programming in Go. They are lightweight threads managed by the Go runtime that enable you to write highly concurrent programs efficiently. This tutorial will guide you from basic goroutine usage to advanced patterns.

1. Goroutine Basics

1.1 Starting Goroutines

Goroutines are started by prefixing a function call with the go keyword. They run concurrently with the calling function.

func say(s string) {
    for i := 0; i < 3; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    // Run in main goroutine
    say("direct call")
    
    // Run in new goroutine
    go say("goroutine")
    
    // Run anonymous function in goroutine
    go func(msg string) {
        fmt.Println(msg)
    }("going")
    
    // Wait for goroutines to finish
    time.Sleep(time.Second)
    fmt.Println("done")
}

1.2 Goroutine Characteristics

Key properties of goroutines:

Lightweight: Start with small 2KB stacks that grow as needed
Cheap: Can create thousands or even millions
Multiplexed: Many goroutines map to fewer OS threads
Non-blocking: Blocked goroutines don't block underlying threads

1.3 Goroutine Scheduling

Go uses an M:N scheduler that multiplexes goroutines onto OS threads:

// Demonstration of goroutine scheduling
func numbers() {
    for i := 1; i <= 5; i++ {
        time.Sleep(250 * time.Millisecond)
        fmt.Printf("%d ", i)
    }
}

func letters() {
    for i := 'a'; i <= 'e'; i++ {
        time.Sleep(400 * time.Millisecond)
        fmt.Printf("%c ", i)
    }
}

func main() {
    go numbers()
    go letters()
    time.Sleep(3 * time.Second)
    fmt.Println("\nmain terminated")
}

2. Goroutine Communication

2.1 Using Channels

Channels are the preferred way to communicate between goroutines.

func sum(s []int, c chan int) {
    sum := 0
    for _, v := range s {
        sum += v
    }
    c <- sum // send sum to c
}

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    
    c := make(chan int)
    go sum(s[:len(s)/2], c)
    go sum(s[len(s)/2:], c)
    
    x, y := <-c, <-c // receive from c
    
    fmt.Println(x, y, x+y) // -5 17 12
}

2.2 Buffered Channels

Buffered channels allow sending without immediate receivers.

func main() {
    // Channel with buffer size 2
    ch := make(chan int, 2)
    
    // Sends don't block until buffer is full
    ch <- 1
    ch <- 2
    
    // Receives work as usual
    fmt.Println(<-ch) // 1
    fmt.Println(<-ch) // 2
}

2.3 Closing Channels

Senders can close channels to indicate no more values will be sent.

func fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int, 10)
    go fibonacci(cap(c), c)
    
    // Receive values until channel is closed
    for i := range c {
        fmt.Println(i)
    }
}

3. Synchronization

3.1 WaitGroups

sync.WaitGroup waits for a collection of goroutines to finish.

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // Decrement counter when done
    
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 5; i++ {
        wg.Add(1) // Increment counter
        go worker(i, &wg)
    }
    
    wg.Wait() // Block until counter is zero
}

3.2 Mutexes

Mutexes protect shared state from concurrent access.

type SafeCounter struct {
    mu    sync.Mutex
    value int
}

func (c *SafeCounter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

func (c *SafeCounter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

3.3 Once

sync.Once ensures initialization code runs exactly once.

var (
    once sync.Once
    instance *Singleton
)

func getInstance() *Singleton {
    once.Do(func() {
        instance = &Singleton{}
    })
    return instance
}

4. Goroutine Patterns

4.1 Worker Pools

A pool of goroutines processing work from a channel.

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        fmt.Printf("worker %d finished job %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    
    // Start 3 workers
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    
    // Send 5 jobs
    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)
    
    // Collect results
    for a := 1; a <= 5; a++ {
        <-results
    }
}

4.2 Fan-out/Fan-in

Distribute work to multiple goroutines and combine results.

func producer(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func merge(cs ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan int)
    
    output := func(c <-chan int) {
        for n := range c {
            out <- n
        }
        wg.Done()
    }
    
    wg.Add(len(cs))
    for _, c := range cs {
        go output(c)
    }
    
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

func main() {
    in := producer(1, 2, 3, 4)
    
    // Fan-out
    c1 := square(in)
    c2 := square(in)
    
    // Fan-in
    for n := range merge(c1, c2) {
        fmt.Println(n) // 1, 4, 9, 16
    }
}

4.3 Pipeline

Chain goroutines together in a processing pipeline.

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    // Set up the pipeline
    c := gen(2, 3)
    out := sq(c)
    
    // Consume the output
    fmt.Println(<-out) // 4
    fmt.Println(<-out) // 9
}

5. Advanced Topics

5.1 Context

context package manages deadlines, cancellations across goroutines.

func worker(ctx context.Context, wg *sync.WaitGroup) {
    defer wg.Done()
    
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker cancelled")
            return
        default:
            // Do work
            fmt.Println("Working...")
            time.Sleep(500 * time.Millisecond)
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()
    
    var wg sync.WaitGroup
    wg.Add(1)
    go worker(ctx, &wg)
    
    wg.Wait()
}

5.2 Select Statement

select lets a goroutine wait on multiple channel operations.

func main() {
    c1 := make(chan string)
    c2 := make(chan string)
    
    go func() {
        time.Sleep(1 * time.Second)
        c1 <- "one"
    }()
    
    go func() {
        time.Sleep(2 * time.Second)
        c2 <- "two"
    }()
    
    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

5.3 Atomic Operations

sync/atomic provides low-level atomic memory operations.

type AtomicCounter struct {
    count int64
}

func (c *AtomicCounter) Inc() {
    atomic.AddInt64(&c.count, 1)
}

func (c *AtomicCounter) Value() int64 {
    return atomic.LoadInt64(&c.count)
}

6. Common Pitfalls

6.1 Goroutine Leaks

Goroutines can leak if they're blocked indefinitely.

// Leaking goroutine example
func leak() {
    ch := make(chan int)
    go func() {
        val := <-ch // Blocked forever
        fmt.Println(val)
    }()
    return // Channel never gets sent to
}

// Fixed version
func noLeak() {
    ch := make(chan int)
    done := make(chan bool)
    
    go func() {
        val := <-ch
        fmt.Println(val)
        done <- true
    }()
    
    ch <- 42 // Send value
    <-done   // Wait for completion
}

6.2 Race Conditions

Data races occur when goroutines access shared data without synchronization.

// Race condition example
var counter int

func increment() {
    counter++
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    time.Sleep(1 * time.Second)
    fmt.Println(counter) // May not be 1000
}

// Fixed with mutex
var (
    counter int
    mu      sync.Mutex
)

func safeIncrement() {
    mu.Lock()
    defer mu.Unlock()
    counter++
}

6.3 Deadlocks

Deadlocks occur when goroutines wait for each other indefinitely.

// Deadlock example
func main() {
    ch := make(chan int)
    ch <- 42      // Send blocks until someone receives
    val := <-ch   // But we never get here
    fmt.Println(val)
}

// Fixed by using buffered channel or separate goroutines
func noDeadlock() {
    ch := make(chan int, 1) // Buffered channel
    ch <- 42
    val := <-ch
    fmt.Println(val)
}

7. Best Practices

7.1 Goroutine Design Principles

Key principles for effective goroutine usage:

Keep goroutines focused: Each should do one thing well
Use channels for communication: Don't share memory directly
Be explicit about ownership: Clearly define which goroutine owns which data
Manage lifetimes: Know when goroutines start and stop

7.2 Error Handling

Proper error handling in concurrent programs:

func worker(id int, jobs <-chan int, results chan<- int, errChan chan<- error) {
    for j := range jobs {
        if j < 0 {
            errChan <- fmt.Errorf("invalid job %d", j)
            continue
        }
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 10)
    results := make(chan int, 10)
    errChan := make(chan error, 10)
    
    go worker(1, jobs, results, errChan)
    
    jobs <- 2
    jobs <- -1 // Will cause error
    close(jobs)
    
    select {
    case err := <-errChan:
        fmt.Println("Error:", err)
    case res := <-results:
        fmt.Println("Result:", res)
    }
}

7.3 Debugging Techniques

Tools and techniques for debugging goroutines:

go run -race: Detects race conditions
runtime.NumGoroutine(): Counts active goroutines
Logging with goroutine IDs
pprof for performance analysis

0 Interaction

0 Views

0 Likes