How to wait for multiple goroutines

Introduction

This comprehensive tutorial explores advanced techniques for managing and synchronizing multiple goroutines in Golang. Designed for developers seeking to enhance their concurrent programming skills, the guide covers essential methods to effectively wait for and coordinate parallel tasks, ensuring robust and efficient code execution in Golang applications.

Skills Graph

Goroutines Basics

What are Goroutines?

Goroutines are lightweight threads managed by the Go runtime. They provide a simple way to achieve concurrent programming in Go, allowing multiple functions to run simultaneously within the same address space.

Creating Goroutines

In Go, you can create a goroutine by using the go keyword followed by a function call:

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine!")
}

func main() {
    go sayHello()
    time.Sleep(time.Second)
}

Goroutine Characteristics

Concurrency vs Parallelism

Anonymous Goroutines

You can also create goroutines using anonymous functions:

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("Running anonymous goroutine")
    }()
    time.Sleep(time.Second)
}

Best Practices

• Use goroutines for I/O-bound or potentially blocking operations
• Avoid creating too many goroutines to prevent resource exhaustion
• Use synchronization mechanisms to coordinate goroutine execution

Common Use Cases

1. Handling multiple network connections
2. Performing background tasks
3. Implementing parallel processing
4. Managing concurrent operations

Note: At LabEx, we recommend practicing goroutine concepts through hands-on coding exercises to build a solid understanding.

Synchronization Methods

Introduction to Synchronization

Synchronization is crucial in concurrent programming to prevent race conditions and ensure safe access to shared resources.

Sync Primitives in Go

1. Mutex (Mutual Exclusion)

package main

import (
    "fmt"
    "sync"
)

type SafeCounter struct {
    mu sync.Mutex
    value int
}

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

2. WaitGroup

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d completed\n", id)
        }(i)
    }
    
    wg.Wait()
    fmt.Println("All goroutines completed")
}

Synchronization Mechanisms Comparison

Channels for Synchronization

package main

import (
    "fmt"
    "time"
)

func worker(done chan bool) {
    time.Sleep(time.Second)
    done <- true
}

func main() {
    done := make(chan bool, 1)
    go worker(done)
    <-done
    fmt.Println("Worker completed")
}

Synchronization Flow

Advanced Synchronization Patterns

Condition Variables

package main

import (
    "fmt"
    "sync"
)

func main() {
    var mu sync.Mutex
    cond := sync.NewCond(&mu)
    
    go func() {
        mu.Lock()
        cond.Wait()
        fmt.Println("Condition met")
        mu.Unlock()
    }()
}

Best Practices

1. Minimize time spent in critical sections
2. Use the simplest synchronization mechanism possible
3. Avoid nested locks to prevent deadlocks

Note: LabEx recommends practicing these synchronization techniques through interactive coding exercises to gain practical experience.

Concurrency Patterns

Common Concurrency Patterns in Go

1. Worker Pool Pattern

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done()
    for job := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, job)
        results <- job * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    var wg sync.WaitGroup

    // Create worker pool
    for w := 1; w <= 3; w++ {
        wg.Add(1)
        go worker(w, jobs, results, &wg)
    }

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

    wg.Wait()
    close(results)

    // Collect results
    for result := range results {
        fmt.Println("Result:", result)
    }
}

Concurrency Pattern Types

Pipeline Pattern

package main

import "fmt"

func generator(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 main() {
    // Pipeline: generate numbers -> square them
    pipeline := square(generator(1, 2, 3, 4))
    
    for v := range pipeline {
        fmt.Println(v)
    }
}

Concurrency Flow Visualization

Fan-Out/Fan-In Pattern

package main

import (
    "fmt"
    "sync"
)

func fanOut(ch <-chan int, out1, out2 chan<- int) {
    for v := range ch {
        out1 <- v
        out2 <- v
    }
    close(out1)
    close(out2)
}

func main() {
    input := make(chan int)
    output1 := make(chan int)
    output2 := make(chan int)

    var wg sync.WaitGroup
    wg.Add(1)

    go func() {
        defer wg.Done()
        fanOut(input, output1, output2)
    }()

    go func() {
        for v := range output1 {
            fmt.Println("Output 1:", v)
        }
    }()

    go func() {
        for v := range output2 {
            fmt.Println("Output 2:", v)
        }
    }()

    // Send inputs
    input <- 1
    input <- 2
    input <- 3
    close(input)

    wg.Wait()
}

Best Practices

1. Use channels for communication between goroutines
2. Keep goroutines small and focused
3. Avoid sharing memory, pass data through channels
4. Use context for cancellation and timeouts

Note: LabEx encourages developers to experiment with these patterns to build robust concurrent applications.

Summary

By mastering these Golang concurrency patterns, developers can create more responsive and performant applications. Understanding synchronization techniques like wait groups, channels, and context management enables precise control over concurrent operations, ultimately leading to more scalable and reliable software solutions in Golang.