Ի՞նչ մոտեցում է կիրառվում Գո-ում գորուտիններում առաջացող սխալները մշակելու համար։

Go-ում գորգինների սխալների մշակման համար սովորաբար օգտագործվում են հետևյալ մոտեցումները:

• Սխալների փոխանցում via ալիքներ: Ստեղծվում է ալիք սխալների փոխանցման համար հիմնական հոսքին կամ այլ գորգին, որը կարող է դրանք մշակել:

  // Օրինակ սխալի փոխանցում via ալիք
  func worker(id int, errors chan<- error) {
    // ... աշխատանքը կատարելը
    if somethingWentWrong {
      errors <- fmt.Errorf("սխալ գորգին %d-ում", id)
      return
    }
    // ... հաջող ավարտ
  }
  
  func main() {
    errorCh := make(chan error, nWorkers) // Բուֆերացված ալիք
    for i := 0; i < nWorkers; i++ {
      go worker(i, errorCh)
    }
  
    for i := 0; i < nWorkers; i++ {
      err := <-errorCh
      if err != nil {
        log.Printf("գտնվել է սխալ: %v", err)
        // Սխալի մշակումը
      }
    }
  }
  

• Օգտագործում sync.WaitGroup և սխալների ալիք: sync.WaitGroup օգնում է սպասել բոլոր գորգինների ավարտին, իսկ ալիքն օգտագործվում է սխալների հավաքագրման համար:

  // Օրինակ WaitGroup և սխալների ալիքով
  func workerWithWG(id int, wg *sync.WaitGroup, errors chan<- error) {
    defer wg.Done()
    // ... աշխատանքը կատարելը
    if somethingWentWrong {
      errors <- fmt.Errorf("սխալ գորգին %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) // Կարևոր է փակել ալիքը WaitGroup-ից հետո
  
    for err := range errorCh {
      log.Printf("գտնվել է սխալ: %v", err)
      // Սխալի մշակումը
    }
  }
  

• Արժեքի և սխալի վերադարձը գորգին մեջ գործարկվող ֆունկցիայից: Եթե գորգը կատարում է կոնկրետ աշխատանք և կարող է վերադարձնել արդյունք և/կամ սխալ, ապա կարելի է այն թաքցնել ֆունկցիայի մեջ, որը վերադարձնում է այդ արժեքները:

  // Օրինակ արժեքի և սխալի վերադարձը ֆունկցիայից
  type result struct {
    value int
    err error
  }
  
  func doSomething(id int) (int, error) {
    // ... աշխատանքը կատարելը
    if somethingWentWrong {
      return 0, fmt.Errorf("սխալ գորգին %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("գտնվել է սխալ: %v", res.err)
        // Սխալի մշակումը
      } else {
        log.Printf("արդյունք: %d", res.value)
      }
    }
  }
  

• Կոնտեքստի (context.Context) օգտագործում՝ չեղարկման և սխալների մշակման համար: Կոնտեքստը կարելի է օգտագործել գորգինների չեղարկման ազդանշան տալու կամ սխալը փոխանցելու համար:

  // Օրինակ կոնտեքստով
  func workerWithContext(ctx context.Context, id int, errors chan<- error) {
    select {
    case <-ctx.Done():
      errors <- fmt.Errorf("գորգին %d չեղարկված է: %v", id, ctx.Err())
      return
    default:
      // ... աշխատանքը կատարելը
      if somethingWentWrong {
        errors <- fmt.Errorf("սխալ գորգին %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)
    }
  
    // Մի որոշ ժամանակ հետո կարող եք կանչել cancel() չեղարկելու համար
    // cancel()
  
    // Սխալների հավաքագրում
    go func() {
      for err := range errorCh {
        log.Printf("գտնվել է սխալ: %v", err)
      }
    }()
  
    // Սպասել ավարտին կամ այլ լոգիկա
    // ...
  }
  

Ընտրությունը կոնկրետ մոտեցման կախված է սխալների մշակման պահանջներից և ծրագրի կառուցվածքից։