Cum se determină limita numărului de goroutines care rulează simultan în limbajul Go?

În limbajul Go, nu există un mecanism încorporat pentru a limita direct numărul de goroutines care rulează simultan. Cu toate acestea, pentru a controla limita de paralelism, se folosesc de obicei semafoare sau canale cu capacitate limitată.

Exemplu de limitare a numărului de goroutines care rulează simultan folosind un canal:

package main

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

func worker(id int, sem chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    sem <- struct{}{} // ocupă un slot
    fmt.Printf("Goroutine %d a început să lucreze\n", id)
    time.Sleep(time.Second) // simulare de muncă
    fmt.Printf("Goroutine %d a terminat de lucrat\n", id)
    <-sem // eliberează slotul
}

func main() {
    const maxGoroutines = 3
    sem := make(chan struct{}, maxGoroutines) // canal cu buffer limitează numărul de goroutines
    var wg sync.WaitGroup

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

În acest exemplu, canalul sem cu bufferul maxGoroutines limitează numărul de goroutines care rulează simultan. Fiecare goroutine, înainte de a începe să lucreze, plasează o structură goal în canal, ocupând un slot, și îl eliberează după ce termină. Astfel, nu vor lucra mai mult de maxGoroutines goroutines în același timp.