Welcher Ansatz wird verwendet, um Fehler in…

In Go werden zur Fehlerbehandlung in Goroutines in der Regel die folgenden Ansätze verwendet:

Fehlerübertragung über Kanäle: Es wird ein Kanal erstellt, um Fehlerwerte an den Haupt- oder einen anderen Goroutine zu übermitteln, die sie verarbeiten kann.

// Beispiel für Fehlerübertragung über einen Kanal
func worker(id int, errors chan<- error) {
  // ... Ausführung der Arbeit
  if somethingWentWrong {
    errors <- fmt.Errorf("Fehler in Goroutine %d", id)
    return
  }
  // ... erfolgreicher Abschluss
}

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

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

Verwendung von sync.WaitGroup und Fehlerkanal: sync.WaitGroup hilft, auf den Abschluss aller Goroutines zu warten, und der Kanal wird zum Sammeln von Fehlern verwendet.

// Beispiel mit WaitGroup und Fehlerkanal
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... Ausführung der Arbeit
  if somethingWentWrong {
    errors <- fmt.Errorf("Fehler 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) // Es ist wichtig, den Kanal nach WaitGroup zu schließen

  for err := range errorCh {
    log.Printf("Fehler erkannt: %v", err)
    // Fehlerbehandlung
  }
}

Rückgabe von Wert und Fehler aus einer Funktion, die in einer Goroutine ausgeführt wird: Wenn die Goroutine eine bestimmte Aufgabe ausführt und einen Wert und/oder Fehler zurückgeben kann, kann sie in eine Funktion eingebettet werden, die diese Werte zurückgibt.

// Beispiel für Rückgabe von Wert und Fehler aus einer Funktion
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... Ausführung der Arbeit
  if somethingWentWrong {
    return 0, fmt.Errorf("Fehler 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("Fehler erkannt: %v", res.err)
      // Fehlerbehandlung
    } else {
      log.Printf("Ergebnis: %d", res.value)
    }
  }
}

Verwendung des Kontexts (context.Context) zum Abbrechen und Behandeln von Fehlern: Der Kontext kann verwendet werden, um das Abbrechen von Goroutines zu signalisieren oder Fehler nach unten in der Aufrufhierarchie zu übertragen.

// Beispiel mit Kontext
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("Goroutine %d abgebrochen: %v", id, ctx.Err())
    return
  default:
    // ... Ausführung der Arbeit
    if somethingWentWrong {
      errors <- fmt.Errorf("Fehler 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)
  }

  // Irgendwann kann cancel() aufgerufen werden, um abzubrechen
  // cancel()

  // Fehler sammeln
  go func() {
    for err := range errorCh {
      log.Printf("Fehler erkannt: %v", err)
    }
  }()

  // Auf Abschluss oder andere Logik warten
  // ...
}

Die Wahl eines bestimmten Ansatzes hängt von den Anforderungen an die Fehlerbehandlung und der Architektur der Anwendung ab.

Welcher Ansatz wird verwendet, um Fehler in Goroutinen in Go zu behandeln?