Code with Go
About
  • Code With Go! 🚀
  • Hello World
  • Values
  • Variables
  • Constants
  • For Loop
  • If Else
  • Switch
  • Array
  • Slice
  • Map
  • Range
  • Functions
  • Multiple Return Values
  • Variadic Functions
  • Closure
  • Recursion
  • Pointers
  • Strings and Runes
  • Structs
  • Methods
  • Interfaces
  • Struct Embedding
  • Generics
  • Error
  • Goroutines
  • Channels
  • Channel Buffering
  • Channel Synchronization
  • Channel Directions
  • Select
  • Timeouts
  • Non-Blocking Channel Operations
  • Closing Channels
  • Range over Channels
  • Timers
  • Tickers
  • Worker Pools
  • Wait Groups
  • Rate Limiting
  • Atomic Counters
  • Mutexes
  • Stateful Goroutines
  • Sorting
  • Sorting by Functions
  • Panic
  • Defer
  • Recover
  • String Functions
  • String Formatting
  • Text Templates
  • Regular Expressions
  • JSON
  • XML
  • Time
  • Epoch
  • Time Formatting / Parsing
  • Random Numbers
  • Number Parsing
  • SHA256 Hashes
  • Base64 Encoding
  • Reading Files
  • Writing Files
  • Line Filters
  • File Paths
  • Directories
  • Temporary Files and Directories
  • Embed Directive
  • Testing and Benchmarking
  • Command-Line Arguments
  • Command-Line Flags
  • Command-Line Subcommands
  • Environment Variables
  • Logging
  • HTTP Client
  • HTTP Server
  • Context
  • Spawning Processes
  • Exec'ing Processes
  • Signals
  • Exit
  • Resize Image
Powered by GitBook
On this page

Was this helpful?

Edit on GitHub

Wait Groups

This Go code demonstrates the use of the sync.WaitGroup to wait for a collection of goroutines to finish their execution. Let's go through it with inline comments:

package main

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

// worker function represents a worker that performs some work
func worker(id int) {
    fmt.Printf("Worker %d starting\n", id)

    // Simulate work by sleeping for one second
    time.Sleep(time.Second)

    fmt.Printf("Worker %d done\n", id)
}

func main() {
    // Creating a WaitGroup to wait for all goroutines to finish
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        // Incrementing the WaitGroup counter for each goroutine
        wg.Add(1)

        // Creating a local variable 'i' to capture the current value
        i := i

        // Launching a goroutine for each worker
        go func() {
            // Decrementing the WaitGroup counter when the goroutine completes
            defer wg.Done()
            worker(i)
        }()
    }

    // Waiting for all goroutines to finish
    wg.Wait()
}

Output

Worker 2 starting
Worker 3 starting
Worker 5 starting
Worker 4 starting
Worker 1 starting
Worker 1 done
Worker 4 done
Worker 5 done
Worker 2 done
Worker 3 done

Explanation:

  1. package main: Indicates that this Go file belongs to the main executable package.

  2. import (...): Imports necessary packages, including "fmt" for formatting and printing, "sync" for synchronization, and "time" for handling time-related operations.

  3. func worker(id int) { ... }: Defines a worker function that simulates work by sleeping for one second and prints messages.

  4. var wg sync.WaitGroup: Creates a sync.WaitGroup variable named 'wg' to wait for a collection of goroutines to finish.

  5. wg.Add(1): Increments the WaitGroup counter for each goroutine to indicate that a new goroutine is starting.

  6. i := i: Creates a local variable 'i' to capture the current value of the loop variable, preventing its value from changing in the closure.

  7. go func() { ... }(): Launches a goroutine for each worker. The defer wg.Done() statement is used to decrement the WaitGroup counter when the goroutine completes.

  8. wg.Wait(): Waits for all goroutines to finish by blocking until the WaitGroup counter becomes zero.

This code demonstrates how to use a sync.WaitGroup to coordinate the execution of multiple goroutines. Each worker is launched as a goroutine, and the WaitGroup is used to wait for all workers to complete their work before proceeding further in the main function. The use of a local variable inside the loop ensures that each goroutine captures the correct value of 'i'.

PreviousWorker PoolsNextRate Limiting

Last updated 1 year ago

Was this helpful?