Ce abordare este utilizată pentru gestionarea…

În Go, pentru tratarea erorilor în gorutine, se folosesc de obicei următoarele abordări:

Transmiterea erorilor prin canale: Se creează un canal pentru transmiterea valorilor de eroare către firul principal sau către altă gorutină care le poate procesa.

// Exemplu de transmitere a erorii prin canal
func worker(id int, errors chan<- error) {
  // ... executarea muncii
  if somethingWentWrong {
    errors <- fmt.Errorf("eroare în gorutină %d", id)
    return
  }
  // ... finalizare cu succes
}

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

  for i := 0; i < nWorkers; i++ {
    err := <-errorCh
    if err != nil {
      log.Printf("eroare detectată: %v", err)
      // Tratarea erorii
    }
  }
}

Utilizarea sync.WaitGroup și canalului de erori: sync.WaitGroup ajută la așteptarea finalizării tuturor gorutinelor, iar canalul este folosit pentru colectarea erorilor.

// Exemplu cu WaitGroup și canal de erori
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... executarea muncii
  if somethingWentWrong {
    errors <- fmt.Errorf("eroare în gorutină %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) // Este important să închidem canalul după WaitGroup

  for err := range errorCh {
    log.Printf("eroare detectată: %v", err)
    // Tratarea erorii
  }
}

Returnarea valorii și a erorii din funcția lansată în gorutină: Dacă gorutina execută o sarcină specifică și poate returna rezultatul și/sau eroarea, se poate înveli într-o funcție care returnează aceste valori.

// Exemplu de returnare a valorii și erorii dintr-o funcție
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... executarea muncii
  if somethingWentWrong {
    return 0, fmt.Errorf("eroare în gorutină %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("eroare detectată: %v", res.err)
      // Tratarea erorii
    } else {
      log.Printf("rezultatul: %d", res.value)
    }
  }
}

Utilizarea contextului (context.Context) pentru anulare și tratarea erorilor: Contextul poate fi folosit pentru a semnala anularea gorutinelor sau pentru a transmite eroarea mai jos în ierarhia apelurilor.

// Exemplu cu context
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("gorutină %d anulată: %v", id, ctx.Err())
    return
  default:
    // ... executarea muncii
    if somethingWentWrong {
      errors <- fmt.Errorf("eroare în gorutină %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)
  }

  // La un moment dat, se poate apela cancel() pentru anulare
  // cancel()

  // Colectarea erorilor
  go func() {
    for err := range errorCh {
      log.Printf("eroare detectată: %v", err)
    }
  }()

  // Așteptarea finalizării sau altă logică
  // ...
}

Alegerea abordării specifice depinde de cerințele de tratare a erorilor și de arhitectura aplicației.

Ce abordare este utilizată pentru gestionarea erorilor apărute în goroutines în Go?