Milyen megközelítést alkalmaznak a Go-ban a…

A Go nyelvben a gorutinokban lévő hibák kezelésére általában a következő megközelítéseket alkalmazzák:

Hibák átadása csatornákon keresztül: Létrehozunk egy csatornát a hibák értékeinek átadására a fő szál vagy egy másik gorutin felé, amely feldolgozhatja azokat.

// Hibák átadásának példája csatornán keresztül
func worker(id int, errors chan<- error) {
  // ... munka végrehajtása
  if somethingWentWrong {
    errors <- fmt.Errorf("hiba a gorutinban %d", id)
    return
  }
  // ... sikeres befejezés
}

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

  for i := 0; i < nWorkers; i++ {
    err := <-errorCh
    if err != nil {
      log.Printf("hiba észlelve: %v", err)
      // Hiba kezelése
    }
  }
}

sync.WaitGroup és hibacsatorna használata: A sync.WaitGroup segít megvárni az összes gorutin befejeződését, a csatorna pedig a hibák gyűjtésére szolgál.

// Példa WaitGroup és hibacsatornával
func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
  defer wg.Done()
  // ... munka végrehajtása
  if somethingWentWrong {
    errors <- fmt.Errorf("hiba a gorutinban %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) // Fontos lezárni a csatornát a WaitGroup után

  for err := range errorCh {
    log.Printf("észlelt hiba: %v", err)
    // Hiba kezelése
  }
}

Érték és hiba visszaadása egy gorutinban futó függvényből: Ha a gorutin egy adott feladatot végez, és eredményt és/vagy hibát adhat vissza, akkor egy olyan függvénybe csomagolható, amely ezeket az értékeket adja vissza.

// Példa érték és hiba visszaadására
type result struct {
  value int
  err error
}

func doSomething(id int) (int, error) {
  // ... munka végrehajtása
  if somethingWentWrong {
    return 0, fmt.Errorf("hiba a gorutinban %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("észlelt hiba: %v", res.err)
      // Hiba kezelése
    } else {
      log.Printf("eredmény: %d", res.value)
    }
  }
}

A kontextus (context.Context) használata a gorutinok leállítására és hibakezelésre: A kontextust használhatjuk a gorutinok leállításának jelzésére vagy a hiba továbbítására az alárendelt hívási hierarchiába.

// Példa kontextussal
func workerWithContext(ctx context.Context, id int, errors chan<- error) {
  select {
  case <-ctx.Done():
    errors <- fmt.Errorf("gorutina %d leállítva: %v", id, ctx.Err())
    return
  default:
    // ... munka végrehajtása
    if somethingWentWrong {
      errors <- fmt.Errorf("hiba a gorutinban %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)
  }

  // Egy ponton meghívható a cancel() a leállításhoz
  // cancel()

  // Hibák gyűjtése
  go func() {
    for err := range errorCh {
      log.Printf("észlelt hiba: %v", err)
    }
  }()

  // Várakozás a befejezésre vagy más logika
  // ...
}

A konkrét megközelítés kiválasztása az alkalmazás hibakezelési követelményeitől és architektúrájától függ.

Milyen megközelítést alkalmaznak a Go-ban a goroutine-okban keletkező hibák kezelésére?