Какой подход используется для обработки ошибок, возникающих в горутинах в Go?

В Go для обработки ошибок в горутинах обычно используют следующие подходы:

• Передача ошибок через каналы: Создается канал для передачи значений ошибок основным потоком или другой горутиной, которая может их обработать.

  // Пример передачи ошибки через канал
  func worker(id int, errors chan<- error) {
    // ... выполнения работы
    if somethingWentWrong {
      errors <- fmt.Errorf("ошибка в горутине %d", id)
      return
    }
    // ... успешное завершение
  }
  
  func main() {
    errorCh := make(chan error, nWorkers) // Буферизированный канал
    for i := 0; i < nWorkers; i++ {
      go worker(i, errorCh)
    }
  
    for i := 0; i < nWorkers; i++ {
      err := <-errorCh
      if err != nil {
        log.Printf("обнаружена ошибка: %v", err)
        // Обработка ошибки
      }
    }
  }
  

• Использование sync.WaitGroup и канала ошибок: sync.WaitGroup помогает дождаться завершения всех горутин, а канал используется для сбора ошибок.

  // Пример с WaitGroup и каналом ошибок
  func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
    defer wg.Done()
    // ... выполнения работы
    if somethingWentWrong {
      errors <- fmt.Errorf("ошибка в горутине %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) // Важно закрыть канал после WaitGroup
  
    for err := range errorCh {
      log.Printf("обнаружена ошибка: %v", err)
      // Обработка ошибки
    }
  }
  

• Возвращение значения и ошибки из функции, запускаемой в горутине: Если горутина выполняет одну конкретную задачу и может вернуть результат и/или ошибку, можно обернуть ее в функцию, которая возвращает эти значения.

  // Пример возврата значения и ошибки из функции
  type result struct {
    value int
    err error
  }
  
  func doSomething(id int) (int, error) {
    // ... выполнение работы
    if somethingWentWrong {
      return 0, fmt.Errorf("ошибка в горутине %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("обнаружена ошибка: %v", res.err)
        // Обработка ошибки
      } else {
        log.Printf("результат: %d", res.value)
      }
    }
  }
  

• Использование контекста (context.Context) для отмены и обработки ошибок: Контекст можно использовать для сигнализации об отмене горутин или для передачи ошибки вниз по иерархии вызовов.

  // Пример с контекстом
  func workerWithContext(ctx context.Context, id int, errors chan<- error) {
    select {
    case <-ctx.Done():
      errors <- fmt.Errorf("горутина %d отменена: %v", id, ctx.Err())
      return
    default:
      // ... выполнение работы
      if somethingWentWrong {
        errors <- fmt.Errorf("ошибка в горутине %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)
    }
  
    // В какой-то момент можно вызвать cancel() для отмены
    // cancel()
  
    // Сбор ошибок
    go func() {
      for err := range errorCh {
        log.Printf("обнаружена ошибка: %v", err)
      }
    }()
  
    // Дождаться завершения или другой логики
    // ...
  }
  

Выбор конкретного подхода зависит от требований к обработке ошибок и архитектуры приложения.