Goroutines are one of Go’s coolest features, but they’re often misunderstood and misused. I’ve seen countless developers make the same mistakes when working with goroutines, and it’s time we set the record straight.

First off, let’s talk about what goroutines actually are. They’re not threads, at least not in the traditional sense. Goroutines are lightweight, user-space threads managed by the Go runtime. This means you can spin up thousands or even millions of goroutines without breaking a sweat. Pretty neat, right?

But here’s where things often go wrong. Developers get excited about this power and start throwing goroutines at every problem they encounter. It’s like giving a kid a hammer and watching them treat everything like a nail. Sure, it might work, but it’s not always the best solution.

One common mistake is creating goroutines without any thought to how they’ll finish. You launch a bunch of goroutines and then… what? Your program exits before they’ve had a chance to complete their work. Oops.

Here’s a classic example of this mistake:

func main() {
    for i := 0; i < 10; i++ {
        go fmt.Println(i)
    }
}

Looks innocent enough, right? But run this, and you’ll likely see nothing printed at all. The main function exits before the goroutines have a chance to run. Rookie mistake.

So how do we fix this? Enter WaitGroups. These nifty little synchronization primitives let us wait for a collection of goroutines to finish. Here’s how we’d rewrite our example:

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(n int) {
            defer wg.Done()
            fmt.Println(n)
        }(i)
    }
    wg.Wait()
}

Much better! Now we’re ensuring all our goroutines complete before the program exits.

Another common pitfall is shared memory access. Goroutines run concurrently, which means they can step on each other’s toes if you’re not careful. I’ve seen codebases brought to their knees by race conditions caused by improper synchronization.

Let’s look at a problematic example:

var counter int

func increment() {
    counter++
}

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

Run this a few times, and you’ll get different results. Sometimes 1000, sometimes less. What gives? We’re running into a race condition. Multiple goroutines are trying to read and write to counter at the same time, leading to unpredictable results.

The fix? Use mutexes to protect shared resources:

var (
    counter int
    mu      sync.Mutex
)

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

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

Now we’re talking! This version will consistently print 1000.

But wait, there’s more! Another common mistake is creating goroutines in a loop using loop variables. It’s a trap that’s easy to fall into if you’re not paying attention. Check this out:

for i := 0; i < 5; i++ {
    go func() {
        fmt.Println(i)
    }()
}

You might expect this to print the numbers 0 through 4 in some order. But more often than not, you’ll see the number 5 printed multiple times. Why? Because the goroutines are capturing the loop variable i by reference, not value. By the time they execute, the loop has finished and i is 5.

The fix is simple:

for i := 0; i < 5; i++ {
    go func(n int) {
        fmt.Println(n)
    }(i)
}

Now we’re passing i as an argument to the goroutine, creating a new value for each iteration.

Let’s talk about channels. They’re Go’s way of letting goroutines communicate with each other, and they’re incredibly powerful. But with great power comes great responsibility, and I’ve seen plenty of developers shoot themselves in the foot with channels.

One common mistake is not closing channels. This can lead to goroutine leaks and deadlocks. Always remember: the sender should close the channel when there’s no more data to send.

Here’s a simple example of using channels correctly:

func producer(ch chan<- int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    close(ch)
}

func main() {
    ch := make(chan int)
    go producer(ch)
    for num := range ch {
        fmt.Println(num)
    }
}

In this example, we’re properly closing the channel when we’re done sending data. This allows the range loop in main to exit when there’s no more data to receive.

Another channel-related mistake is not handling the closed channel case. When a channel is closed, receives from the channel will always succeed immediately, returning the zero value for the channel’s type. This can lead to some nasty bugs if you’re not careful.

Here’s how to handle it properly:

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
        close(ch)
    }()

    for {
        value, ok := <-ch
        if !ok {
            fmt.Println("Channel closed")
            break
        }
        fmt.Println(value)
    }
}

By checking the second return value from the channel receive operation, we can detect when the channel has been closed and handle it appropriately.

Now, let’s talk about context. The context package is a powerful tool for managing goroutines, especially when it comes to cancellation and timeouts. But I’ve seen many developers overlook it entirely.

Here’s an example of using context for cancellation:

func worker(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Worker cancelled")
            return
        default:
            fmt.Println("Working...")
            time.Sleep(time.Second)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go worker(ctx)

    time.Sleep(3 * time.Second)
    cancel()
    time.Sleep(time.Second)
}

In this example, we’re using context to gracefully cancel the worker goroutine after 3 seconds.

One last thing I want to touch on is error handling in goroutines. It’s easy to forget that panics in goroutines won’t be caught by recover in the main goroutine. This can lead to some nasty surprises if you’re not careful.

Here’s a pattern I like to use for handling errors in goroutines:

func worker(errChan chan<- error) {
    defer func() {
        if r := recover(); r != nil {
            errChan <- fmt.Errorf("panic: %v", r)
        }
    }()

    // Do some work that might panic
    panic("oops")
}

func main() {
    errChan := make(chan error)
    go worker(errChan)

    if err := <-errChan; err != nil {
        fmt.Println("Worker error:", err)
    }
}

This pattern allows us to catch and handle panics in goroutines, preventing them from crashing our entire program.

In conclusion, goroutines are a powerful feature of Go, but they need to be used with care. Always make sure your goroutines have a way to finish, use proper synchronization when accessing shared resources, be mindful of closure pitfalls, handle channels correctly, leverage context for cancellation, and don’t forget about error handling.

Remember, just because you can use a goroutine doesn’t mean you should. Sometimes a simple sequential approach is clearer and more maintainable. As with any powerful tool, the key is knowing when and how to use it effectively. Happy coding, Gophers!