Welke aanpak wordt gebruikt voor het afhandelen van…

In Go worden voor foutafhandeling in goroutines meestal de volgende benaderingen gebruikt:

Fouten doorgeven via kanalen: Er wordt een kanaal gemaakt om foutwaarden door te geven aan de hoofd- of een andere goroutine die ze kan verwerken.

// Voorbeeld van fout doorgeven via een kanaal
func worker(id int, errors chan<- error) {
  // ... uitvoering van het werk
  if somethingWentWrong {
    errors <- fmt.Errorf("fout in goroutine %d", id)
    return
  }
  // ... succesvolle afronding
}

func main() {
  errorCh := make(chan error, nWorkers) // Gecoördineerd kanaal
  for i := 0; i < nWorkers; i++ {
    go worker(i, errorCh)
  }

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

Gebruik van sync.WaitGroup en foutkanaal: sync.WaitGroup helpt te wachten tot alle goroutines klaar zijn, en het kanaal wordt gebruikt om fouten te verzamelen.

// Voorbeeld met WaitGroup en foutkanaal
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... uitvoering van het werk
  if somethingWentWrong {
    errors <- fmt.Errorf("fout 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) // Belangrijk om het kanaal te sluiten na WaitGroup

  for err := range errorCh {
    log.Printf("gedetecteerde fout: %v", err)
    // Foutafhandeling
  }
}

Teruggeven van waarde en fout uit een functie die in een goroutine wordt uitgevoerd: Als de goroutine een specifieke taak uitvoert en een resultaat en/of fout kan teruggeven, kan deze worden ingepakt in een functie die deze waarden retourneert.

// Voorbeeld van waarde en fout teruggeven uit een functie
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... uitvoering van het werk
  if somethingWentWrong {
    return 0, fmt.Errorf("fout 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("gedetecteerde fout: %v", res.err)
      // Foutafhandeling
    } else {
      log.Printf("resultaat: %d", res.value)
    }
  }
}

Gebruik van context.Context voor annulering en foutafhandeling: Context kan worden gebruikt om het annuleren van goroutines te signaleren of fouten door te geven in de hiërarchie van aanroepen.

// Voorbeeld met context
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("goroutine %d geannuleerd: %v", id, ctx.Err())
    return
  default:
    // ... uitvoering van het werk
    if somethingWentWrong {
      errors <- fmt.Errorf("fout 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)
  }

  // Op een bepaald moment kan cancel() worden aangeroepen om te annuleren
  // cancel()

  // Foutverzameling
  go func() {
    for err := range errorCh {
      log.Printf("gedetecteerde fout: %v", err)
    }
  }()

  // Wachten op voltooiing of andere logica
  // ...
}

De keuze voor een specifieke aanpak hangt af van de eisen voor foutafhandeling en de architectuur van de applicatie.

Welke aanpak wordt gebruikt voor het afhandelen van fouten die optreden in goroutines in Go?