Jakie podejście jest używane do obsługi błędów…

W Go, do obsługi błędów w gorutynach zwykle stosuje się następujące podejścia:

Przesyłanie błędów przez kanały: Tworzy się kanał do przesyłania wartości błędów do głównej gorutiny lub innej gorutiny, która może je obsłużyć.

// Przykład przesyłania błędu przez kanał
func worker(id int, errors chan<- error) {
  // ... wykonanie pracy
  if somethingWentWrong {
    errors <- fmt.Errorf("błąd w gorutynie %d", id)
    return
  }
  // ... pomyślne zakończenie
}

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

  for i := 0; i < nWorkers; i++ {
    err := <-errorCh
    if err != nil {
      log.Printf("zidentyfikowano błąd: %v", err)
      // Obsługa błędu
    }
  }
}

Użycie sync.WaitGroup i kanału błędów: sync.WaitGroup pomaga oczekiwać na zakończenie wszystkich gorutyn, a kanał służy do zbierania błędów.

// Przykład z WaitGroup i kanałem błędów
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... wykonanie pracy
  if somethingWentWrong {
    errors <- fmt.Errorf("błąd w gorutynie %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) // Ważne jest zamknięcie kanału po WaitGroup

  for err := range errorCh {
    log.Printf("zidentyfikowano błąd: %v", err)
    // Obsługa błędu
  }
}

Zwracanie wartości i błędu z funkcji uruchamianej w gorutynie: Jeśli gorutyna wykonuje konkretne zadanie i może zwrócić wynik i/lub błąd, można ją opakować w funkcję, która zwraca te wartości.

// Przykład zwracania wartości i błędu z funkcji
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... wykonanie pracy
  if somethingWentWrong {
    return 0, fmt.Errorf("błąd w gorutynie %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("zidentyfikowano błąd: %v", res.err)
      // Obsługa błędu
    } else {
      log.Printf("wynik: %d", res.value)
    }
  }
}

Użycie kontekstu (context.Context) do anulowania i obsługi błędów: Kontekst może być używany do sygnalizowania anulowania gorutyn lub do przekazywania błędów w dół hierarchii wywołań.

// Przykład z kontekstem
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("gorutyna %d anulowana: %v", id, ctx.Err())
    return
  default:
    // ... wykonanie pracy
    if somethingWentWrong {
      errors <- fmt.Errorf("błąd w gorutynie %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)
  }

  // W pewnym momencie można wywołać cancel() aby anulować
  // cancel()

  // Zbieranie błędów
  go func() {
    for err := range errorCh {
      log.Printf("zidentyfikowano błąd: %v", err)
    }
  }()

  // Czekać na zakończenie lub inną logikę
  // ...
}

Wybór konkretnego podejścia zależy od wymagań dotyczących obsługi błędów i architektury aplikacji.

Jakie podejście jest używane do obsługi błędów występujących w gorutynach w Go?