Mastering Goroutine Limits: How to Control Go Concurrency Efficiently

Goroutine

Goroutine is a lightweight thread managed by the Go runtime. Concurrency in Go is primarily created with the go keyword, and goroutines communicate via channels, which act as pipelines and prevent race conditions when accessing shared memory.

Creating Goroutines

// ordinary function
go functionName(args)

// anonymous function
go func(args) {
    // function body
}(args)

How many goroutines can be started?

Launching an extremely large number, such as math.MaxInt32, results in a panic like “panic: too many concurrent operations on a single file or socket (max 1048575)”, indicating the system limit has been exceeded.

Controlling Goroutine Count

Use sync.WaitGroup to start a specified number of goroutines.

func testRoutine() {
    var wg = sync.WaitGroup{}
    taskCount := 5 // desired concurrency
    for i := 0; i < taskCount; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Println("go func", i)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

If taskCount is set too high, it still may exceed limits. A pool‑like design using a buffered channel can restrict the maximum number of concurrent goroutines.

func testRoutine() {
    task_chan := make(chan bool, 3) // channel capacity 3
    wg := sync.WaitGroup{}
    defer close(task_chan)
    for i := 0; i < math.MaxInt; i++ {
        wg.Add(1)
        fmt.Println("go func", i)
        task_chan <- true
        go func() {
            <-task_chan
            defer wg.Done()
        }()
    }
    wg.Wait()
}

Create a channel with buffer size 3; sending blocks when the buffer is full, limiting concurrency.

Before launching a goroutine, send a token to the channel; if the buffer is full, the launch blocks.

When a goroutine finishes, it releases the token by receiving from the channel.

All goroutines are waited on via sync.WaitGroup, though the channel alone can also control completion.

Reference: boilingfrog.github.io/2021/04/14/控制goroutine的数量/