What approach is used for handling errors that occur…

In Go, the common approaches for error handling in goroutines include:

Passing errors through channels: Create a channel to send error values to the main thread or another goroutine that can handle them.

// Example of passing an error through a channel
func worker(id int, errors chan<- error) {
  // ... perform work
  if somethingWentWrong {
    errors <- fmt.Errorf("error in goroutine %d", id)
    return
  }
  // ... successful completion
}

func main() {
  errorCh := make(chan error, nWorkers) // Buffered channel
  for i := 0; i < nWorkers; i++ {
    go worker(i, errorCh)
  }

  for i := 0; i < nWorkers; i++ {
    err := <-errorCh
    if err != nil {
      log.Printf("error detected: %v", err)
      // Handle error
    }
  }
}

Using sync.WaitGroup and an error channel: sync.WaitGroup helps wait for all goroutines to finish, and a channel is used to collect errors.

// Example with WaitGroup and error channel
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... perform work
  if somethingWentWrong {
    errors <- fmt.Errorf("error in goroutine %d", id)
  }
}

func main() {
  var wg sync.WaitGroup
  errorCh := make(chan error, nWorkers)

  for i := 0; i < nWorkers; i++ {
    wg.Add(1)
    go workerWithWG(i, &wg, errorCh)
  }

  wg.Wait()
  close(errorCh) // Important to close the channel after WaitGroup

  for err := range errorCh {
    log.Printf("error detected: %v", err)
    // Handle error
  }
}

Returning value and error from a function run as a goroutine: If a goroutine performs a specific task and can return a result and/or an error, it can be wrapped in a function that returns these values.

// Example of returning value and error from a function
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... perform work
  if somethingWentWrong {
    return 0, fmt.Errorf("error in goroutine %d", id)
  }
  return id * 10, nil
}

func main() {
  results := make(chan result, nWorkers)

  for i := 0; i < nWorkers; i++ {
    go func(idx int) {
      val, err := doSomething(idx)
      results <- result{val, err}
    }(i)
  }

  for i := 0; i < nWorkers; i++ {
    res := <-results
    if res.err != nil {
      log.Printf("error detected: %v", res.err)
      // Handle error
    } else {
      log.Printf("result: %d", res.value)
    }
  }
}

Using context (context.Context) for cancellation and error handling: Context can be used to signal goroutine cancellation or to pass errors down the call hierarchy.

// Example with context
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("goroutine %d canceled: %v", id, ctx.Err())
    return
  default:
    // ... perform work
    if somethingWentWrong {
      errors <- fmt.Errorf("error in goroutine %d", id)
    }
  }
}

func main() {
  ctx, cancel := context.WithCancel(context.Background())
  errorCh := make(chan error, nWorkers)

  for i := 0; i < nWorkers; i++ {
    go workerWithContext(ctx, i, errorCh)
  }

  // At some point, cancel() can be called to cancel
  // cancel()

  // Collect errors
  go func() {
    for err := range errorCh {
      log.Printf("error detected: %v", err)
    }
  }()

  // Wait for completion or other logic
  // ...
}

The specific approach depends on the error handling requirements and the application's architecture.

What approach is used for handling errors that occur in goroutines in Go?