Go Concurrency: Making Your Programs Do Multiple Things at Once

The Coffee Shop That Changed Everything

Why Traditional Programs Feel Slow

Task 1 → Complete → Task 2 → Complete → Task 3 → Complete

• Download files while updating the UI
• Handle thousands of web requests at once
• Process data streams continuously
• Talk to multiple databases simultaneously

Go blog diagram 1

Think Like a Restaurant Kitchen

Think of it like this: A busy restaurant kitchen isn't one chef doing everything. It's multiple cooks working on different dishes at the same time. One prepares appetizers, another handles the main course, a third works on desserts. They share resources like the stove and refrigerator, but work independently on their tasks.

Goroutines: Your Lightweight Workers

Go blog diagram 2

go
// Filename: goroutine_basics.go
package main

import (
    "fmt"
    "time"
)

// brewCoffee simulates making a coffee order
// Why: Demonstrates a task that takes time to complete
func brewCoffee(order string) {
    fmt.Printf("Starting: %s\n", order)
    time.Sleep(2 * time.Second) // Simulates brewing time
    fmt.Printf("Completed: %s\n", order)
}

func main() {
    orders := []string{"Latte", "Espresso", "Cappuccino", "Americano"}

    start := time.Now()

    // Start each order as a separate goroutine
    // Why: Each barista (goroutine) works independently
    for _, order := range orders {
        go brewCoffee(order) // The 'go' keyword creates a goroutine
    }

    // Wait for all goroutines to finish
    // Why: main() exits immediately without this, killing all goroutines
    time.Sleep(3 * time.Second)

    fmt.Printf("All orders completed in: %v\n", time.Since(start))
}

Starting: Americano
Starting: Latte
Starting: Cappuccino
Starting: Espresso
Completed: Latte
Completed: Cappuccino
Completed: Americano
Completed: Espresso
All orders completed in: 3.001s

What Makes Goroutines Special

Go blog diagram 3

A Real World Example: Web Scraper

go
// Filename: website_checker.go
package main

import (
    "fmt"
    "net/http"
    "time"
)

// checkWebsite verifies if a website responds
// Why: Real-world use case for concurrent operations
// Parameters:
//   - url: website to check
// Time Complexity: O(1) per request, but wait time varies
func checkWebsite(url string) {
    start := time.Now()

    // Create HTTP client with timeout
    // Why: Prevents hanging forever on unresponsive sites
    client := http.Client{
        Timeout: 5 * time.Second,
    }

    resp, err := client.Get(url)
    duration := time.Since(start)

    if err != nil {
        fmt.Printf("FAIL: %s (Error: %v)\n", url, err)
        return
    }
    defer resp.Body.Close()

    fmt.Printf("OK: %s (Status: %d, Time: %v)\n", url, resp.StatusCode, duration)
}

func main() {
    websites := []string{
        "https://google.com",
        "https://github.com",
        "https://golang.org",
        "https://stackoverflow.com",
        "https://amazon.com",
    }

    start := time.Now()

    // Check all websites concurrently
    // Why: Network I/O is perfect for concurrency
    for _, site := range websites {
        go checkWebsite(site)
    }

    // Wait for completion
    // Note: We'll learn better synchronization methods later
    time.Sleep(6 * time.Second)

    fmt.Printf("\nTotal time: %v\n", time.Since(start))
}

OK: https://google.com (Status: 200, Time: 245ms)
OK: https://golang.org (Status: 200, Time: 312ms)
OK: https://github.com (Status: 200, Time: 287ms)
OK: https://stackoverflow.com (Status: 200, Time: 456ms)
OK: https://amazon.com (Status: 200, Time: 523ms)

Total time: 6.001s

The Execution Model Explained

Go blog diagram 4

1. Goroutine Creation: Go allocates a small stack (about 2KB)
2. Scheduling: The Go scheduler adds it to a run queue
3. Execution: The scheduler runs goroutines across available CPU cores
4. Completion: When done, the goroutine's resources are cleaned up

When Concurrency Shines

• Reading/writing files
• Network requests
• Database queries

• Processing items in a batch
• Handling separate user requests
• Running parallel computations

Go blog diagram 5

Common Mistakes to Avoid

go
// WRONG: Program exits before goroutine runs
func main() {
    go fmt.Println("Hello!")
    // Program ends here, goroutine never prints
}

// RIGHT: Wait for goroutine to complete
func main() {
    go fmt.Println("Hello!")
    time.Sleep(time.Second) // Gives goroutine time to run
}

go
// WRONG: All goroutines might print the same value
for i := 0; i < 5; i++ {
    go func() {
        fmt.Println(i) // Captures i by reference
    }()
}

// RIGHT: Pass i as a parameter
for i := 0; i < 5; i++ {
    go func(n int) {
        fmt.Println(n) // Each goroutine gets its own copy
    }(i)
}

Performance Comparison

What You Learned

• Goroutines are lightweight: Create thousands without worry
• The go keyword is simple: Just prefix any function call
• Concurrency speeds up I/O bound tasks: Network, disk, and database operations benefit most
• The Go runtime manages complexity: No manual thread management

Your Next Steps

• Practice: Convert a sequential file processor to use goroutines
• Read Next: Learn about channels for goroutine communication
• Explore: Check out the runtime package to see goroutine statistics

Quick Reference

go
// Create a goroutine
go someFunction()

// Anonymous goroutine
go func() {
    // do something
}()

// With parameters
go func(x int) {
    fmt.Println(x)
}(42)