როგორ განვსაზღვროთ ერთდროულად დაწყებული goroutine-ების რაოდენობის ზღვარი Go ენაში?

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

მაგალითი ერთდროულად მუშაობს goroutine-ების რაოდენობის შეზღუდვისთვის არხის გამოყენებით:

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, sem chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    sem <- struct{}{} // ადგილის დაკავება
    fmt.Printf("Goroutine %d დაიწყო მუშაობა\n", id)
    time.Sleep(time.Second) // სამუშაოს იმიტაცია
    fmt.Printf("Goroutine %d დასრულდა მუშაობა\n", id)
    <-sem // ადგილის გათავისუფლება
}

func main() {
    const maxGoroutines = 3
    sem := make(chan struct{}, maxGoroutines) // არხი ბუფერით, შეზღუდავს goroutine-ების რაოდენობას
    var wg sync.WaitGroup

    for i := 1; i <= 10; i++ {
        wg.Add(1)
        go worker(i, sem, &wg)
    }
    wg.Wait()
}

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