Hoe bepaal je de limiet op het aantal gelijktijdig uitgevoerde goroutines in de Go-taal?

In de programmeertaal Go is er geen ingebouwd mechanisme om het aantal gelijktijdig uitgevoerde goroutines direct te beperken. Om het parallelisme te controleren, worden meestal semaforen of kanalen met beperkte capaciteit gebruikt.

Voorbeeld van het beperken van het aantal gelijktijdige goroutines met behulp van een kanaal:

package main

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

func worker(id int, sem chan struct{}, wg *sync.WaitGroup) {
    defer wg.Done()
    sem <- struct{}{} // een plek reserveren
    fmt.Printf("Goroutine %d is begonnen\n", id)
    time.Sleep(time.Second) // werk simuleren
    fmt.Printf("Goroutine %d is klaar\n", id)
    <-sem // plek vrijmaken
}

func main() {
    const maxGoroutines = 3
    sem := make(chan struct{}, maxGoroutines) // kanaal met buffer beperkt aantal goroutines
    var wg sync.WaitGroup

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

In dit voorbeeld beperkt het kanaal sem met buffer maxGoroutines het aantal gelijktijdig werkende goroutines. Elke goroutine plaatst een lege structuur in het kanaal voordat hij begint met werken, waardoor een plek wordt ingenomen, en geeft deze vrij nadat hij klaar is. Op deze manier werken nooit meer dan maxGoroutines goroutines tegelijk.