როგორ განვახორციელოთ უსაფრთხო მონაცემების წაკითხვა არხიდან ერთდროულად რამდენიმე goroutine-ით?

Go ბილიკში, უსაფრთხო წაკითხვა ერთდროულად რამდენიმე goroutine-დან ერთ არხზე ჩვეულებრივ გამოიყენება შემდეგი მიდგომებიდან ერთ-ერთი:

1. ერთი გამგზავნი, რამდენიმე მიმღები — ქმნიან არხს და რამდენიმე goroutine-ი კითხულობს მასიდან. Go-ში არხი უსაფრთხოა ერთდროულად რამდენიმე goroutine-ის მიერ წაკითხვისთვის, ამიტომ შესაძლებელია უბრალოდ რამდენიმე goroutine-ის გაშვება, რომლებიც ერთ არხზე კითხულობენ.

2. sync.WaitGroup-ის გამოყენება სინქრონიზაციისთვის — რათა დაელოდოთ ყველა goroutine-ის დასრულებას.

მაგალითი:

package main

import (
    "fmt"
    "sync"
)

func worker(id int, ch <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for val := range ch {
        fmt.Printf("მუშაკი %d მიიღო %d\n", id, val)
    }
}

func main() {
    ch := make(chan int)
    var wg sync.WaitGroup

    // 3 goroutine-ის გაშვება, რომლებიც კითხულობენ არხიდან
    for i := 1; i <= 3; i++ {
        wg.Add(1)
        go worker(i, ch, &wg)
    }

    // მონაცემების გაგზავნა არხზე
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // არხის დახურვა, რათა goroutine-ები დასრულდნენ

    wg.Wait() // ველით ყველა goroutine-ის დასრულებას
}

ამ გზით, Go-ის არხი უკვე უზრუნველყოფს უსაფრთხო წაკითხვას რამდენიმე goroutine-დან, მთავარი ის არის, რომ სწორად მართოთ მათი სიცოცხლის ციკლი და დახუროთ არხი.