Какъв подход се използва за обработка на грешки…

В 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)
    }
  }()

  // Изчакване за завършване или друга логика
  // ...
}

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

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