Hoe kun je het aantal actieve threads in een applicatie controleren?

In Go wordt meestal synchronisatie- en limitiemechanismen gebruikt om het aantal actieve threads (goroutines) te controleren:

• Gebufferde kanalen als semaforen: maken een kanaal met beperkte capaciteit en sturen er een waarde in voordat een goroutine wordt gestart, en ontvangen er een nadat deze is voltooid, waardoor het aantal gelijktijdige goroutines wordt beperkt.

• Pakket sync.WaitGroup: helpt te wachten tot een groep goroutines klaar is, maar beperkt het niet in aantal.

• Pakket golang.org/x/sync/semaphore: biedt een handige semafoor om parallelisme te beperken.

Voorbeeld met een semafoorkanalen:

sem := make(chan struct{}, 5) // maximaal 5 gelijktijdige goroutines

for _, task := range tasks {
    sem <- struct{}{} // blokkeert als er al 5 goroutines actief zijn
    go func(t Task) {
        defer func() { <-sem }() // vrijgeven van een slot
        process(t)
    }(task)
}

// Wacht tot alle goroutines klaar zijn
for i := 0; i < cap(sem); i++ {
    sem <- struct{}{}
}

Op deze manier kan het aantal actieve threads worden gecontroleerd en overmatig resourcegebruik worden voorkomen.