How to use WaitGroup for goroutine synchronization

Introduction

In the world of Golang, effective goroutine synchronization is crucial for building robust and efficient concurrent applications. This tutorial explores WaitGroup, a powerful synchronization primitive that enables developers to coordinate multiple goroutines and manage their execution seamlessly. By understanding WaitGroup, you'll learn how to control concurrent operations and ensure proper synchronization in your Golang projects.

Skills Graph

WaitGroup Basics

Introduction to WaitGroup

In Golang, concurrent programming is a powerful feature, and sync.WaitGroup is a crucial synchronization primitive for managing goroutines. A WaitGroup allows you to wait for a collection of goroutines to complete their execution before proceeding further.

Core Concepts

What is WaitGroup?

A WaitGroup is a synchronization mechanism that helps coordinate multiple goroutines. It provides three primary methods:

Basic Workflow

Simple Example

Here's a basic implementation demonstrating WaitGroup usage:

package main

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

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

func main() {
    var wg sync.WaitGroup
    
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }
    
    wg.Wait()
    fmt.Println("All workers completed")
}

Key Takeaways

• WaitGroup helps synchronize multiple goroutines
• Always call Add() before launching goroutines
• Use Done() to mark goroutine completion
• Wait() blocks until all goroutines finish

Note: When using WaitGroup with LabEx's concurrent programming tutorials, ensure you understand these fundamental principles.

Synchronization Techniques

Advanced WaitGroup Patterns

Concurrent Resource Processing

WaitGroup becomes powerful when managing complex concurrent tasks. Here's a sophisticated synchronization approach:

package main

import (
    "fmt"
    "sync"
)

func processResource(id int, resources []string, wg *sync.WaitGroup, mu *sync.Mutex) {
    defer wg.Done()
    mu.Lock()
    defer mu.Unlock()
    fmt.Printf("Processing resource: %s\n", resources[id])
}

func main() {
    resources := []string{"database", "network", "storage", "cache"}
    var wg sync.WaitGroup
    var mu sync.Mutex

    for i := 0; i < len(resources); i++ {
        wg.Add(1)
        go processResource(i, resources, &wg, &mu)
    }

    wg.Wait()
    fmt.Println("All resources processed")
}

Synchronization Strategies

Concurrent Patterns

Synchronization Techniques Comparison

Error Handling and Coordination

Safe Goroutine Management

func coordinatedTask(tasks []string) error {
    var wg sync.WaitGroup
    errChan := make(chan error, len(tasks))

    for _, task := range tasks {
        wg.Add(1)
        go func(t string) {
            defer wg.Done()
            if err := processTask(t); err != nil {
                errChan <- err
            }
        }(task)
    }

    wg.Wait()
    close(errChan)

    for err := range errChan {
        if err != nil {
            return err
        }
    }

    return nil
}

Best Practices

• Use Add() before goroutine launch
• Call Done() in deferred functions
• Combine with mutexes for complex scenarios
• Consider error channels for robust error handling

Note: LabEx recommends mastering these synchronization techniques for efficient concurrent programming.

Practical Examples

Real-World WaitGroup Scenarios

1. Parallel Web Scraping

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
)

func fetchURL(url string, wg *sync.WaitGroup, results chan string) {
    defer wg.Done()
    resp, err := http.Get(url)
    if err != nil {
        results <- fmt.Sprintf("Error fetching %s: %v", url, err)
        return
    }
    defer resp.Body.Close()
    
    body, _ := ioutil.ReadAll(resp.Body)
    results <- fmt.Sprintf("%s: %d bytes", url, len(body))
}

func main() {
    urls := []string{
        "https://www.example.com",
        "https://www.github.com",
        "https://www.golang.org",
    }

    var wg sync.WaitGroup
    results := make(chan string, len(urls))

    for _, url := range urls {
        wg.Add(1)
        go fetchURL(url, &wg, results)
    }

    // Wait for all goroutines to complete
    go func() {
        wg.Wait()
        close(results)
    }()

    // Collect and print results
    for result := range results {
        fmt.Println(result)
    }
}

2. Concurrent File Processing

func processFiles(files []string) {
    var wg sync.WaitGroup
    var mu sync.Mutex
    processedFiles := []string{}

    for _, file := range files {
        wg.Add(1)
        go func(filepath string) {
            defer wg.Done()
            
            // Simulate file processing
            content, err := ioutil.ReadFile(filepath)
            if err != nil {
                fmt.Printf("Error processing %s: %v\n", filepath, err)
                return
            }

            mu.Lock()
            processedFiles = append(processedFiles, filepath)
            mu.Unlock()
        }(file)
    }

    wg.Wait()
    fmt.Printf("Processed %d files\n", len(processedFiles))
}

Synchronization Patterns

Practical Synchronization Scenarios

Advanced Techniques

Timeout Management

func processWithTimeout(tasks []string, timeout time.Duration) {
    var wg sync.WaitGroup
    done := make(chan bool)

    go func() {
        wg.Wait()
        close(done)
    }()

    select {
    case <-done:
        fmt.Println("All tasks completed")
    case <-time.After(timeout):
        fmt.Println("Processing timed out")
    }
}

Key Takeaways

• WaitGroup enables efficient concurrent processing
• Combine with channels for advanced synchronization
• Use mutexes to protect shared resources
• Implement timeouts for long-running tasks

Note: LabEx encourages exploring these practical WaitGroup applications to master concurrent programming in Go.

Summary

Mastering WaitGroup is essential for Golang developers seeking to implement sophisticated concurrent programming techniques. By leveraging WaitGroup, you can create more responsive, efficient, and scalable applications that effectively manage parallel tasks and synchronize goroutine execution. The techniques and examples demonstrated in this tutorial provide a solid foundation for building high-performance concurrent systems in Golang.