Introduction

Concurrency is one of Go's superpowers, enabling developers to run tasks in parallel using go routines. A go routine is launched with the go keyword followed by a function call, as shown below:

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

Go playground link to the example

This simple example prints "hello" and "world" concurrently. However, the Go language specification notes that if a function called in a goroutine returns values, those values are discarded. This raises a question: how can we capture and use return values from a goroutine?

In this article, we'll explore how to wrap goroutines in anonymous functions to handle return values effectively, address synchronization challenges, and manage errors in concurrent Go programs.

Understanding Goroutine Return Values

The Go specification defines a GoStmt as

GoStmt = "go" Expression .

where the expression must be a function call. Attempting to use a non-function-call expression results in the error: expression in go must be function call.

To capture return values, we can wrap the function call in an anonymous function. Here's a basic example:

package main

import (
    "fmt"
    "time"
)

func main() {

    a := 10
    fmt.Println("Value of a before goroutine", a)
    go func() {
        a += 10
    }()

    time.Sleep(1 * time.Second)
    fmt.Println("Value of a after goroutine call", a)
}

Go playground link to the example

In this example, an anonymous function modifies the variable a. However, using time.Sleep for synchronization is unreliable, as it doesn't guarantee the goroutine has completed. Additionally, concurrent access to a could lead to race conditions. We'll address these issues later.

A Practical Example with Synchronization 

package main

import (
    "fmt"
    "sync"
)

func main() {
    fName := "John"
    lName := "Doe"
    var fullName string
    var errs []error
    var mu sync.Mutex // Protects shared variables
    var wg sync.WaitGroup

    // Process full name with valid input
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName(fName, lName)
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    // Process full name with empty first name
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName("", lName)
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    // Process full name with empty last name
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName(fName, "")
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    wg.Wait() // Wait for all goroutines to complete

    if len(errs) > 0 {
        fmt.Println("Errors encountered:")
        for _, err := range errs {
            fmt.Println(" -", err)
        }
    }
    fmt.Println("User's fullName:", fullName)
}

func generateFullName(firstName, lastName string) (string, error) {
    if firstName == "" {
        return "", fmt.Errorf("firstName is empty")
    }
    if lastName == "" {
        return "", fmt.Errorf("lastName is empty")
    }
    return fmt.Sprintf("%s %s", firstName, lastName), nil
}

Go playground link to the example

Key Improvements in This Example

  1. Synchronization with sync.WaitGroup: We use wg.Add(1) to increment the WaitGroup counter before each goroutine and wg.Done() to signal completion. wg.Wait() ensures the main function waits for all goroutines to finish.
  2. Thread-Safe Updates with sync.Mutex: The mu mutex protects fullName and errs from concurrent access, preventing race conditions.
  3. Error Collection: Errors are collected in a slice, allowing the program to report all issues rather than stopping at the first error.
  4. Clear Output: The program prints all errors and the final fullName, making it easier to debug and understand the results.

Benefits of Wrapping Goroutines

By wrapping function calls in anonymous goroutines, you gain flexibility to:

  1. Log Errors and Metrics: Send errors to a logging system or increment counters in a monitoring tool.
  2. Process Results: Set default values, update flags, or transform data based on the return values.
  3. Collect Errors: Aggregate errors from multiple goroutines for comprehensive validation (e.g., checking user inputs).
  4. Retry Logic: Implement retry mechanisms for transient errors, such as network failures.

Conclusion

Wrapping goroutines in anonymous functions is a powerful technique for capturing return values and managing errors in concurrent Go programs. By combining this approach with proper synchronization tools like sync.WaitGroup and sync.Mutex, you can build robust and efficient concurrent applications. Experiment with these patterns in your projects, and share your experiences.