How can i use gomaxprocs? The code below sets gomaxprocs, but then more workers are spawned that set. I expect 2 processes but 5 are still run.

package main

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

func worker(i int, waiter chan struct{}, wg *sync.WaitGroup) {
    defer func(waiter chan struct{}, wg *sync.WaitGroup) {
        fmt.Printf("worker %d done\n", i)
        wg.Done()
        <-waiter

    }(waiter, wg)
    fmt.Printf("worker %d starting\n", i)
    time.Sleep(time.Second)
}
func main() {
    runtime.GOMAXPROCS(2)
    var concurrency = 5
    var items = 10

    waiter := make(chan struct{}, concurrency)
    var wg sync.WaitGroup

    for i := 0; i < items; i   {
        wg.Add(1)
        waiter <- struct{}{}
        go worker(i, waiter, &wg)
    }
    wg.Wait()
}

CodePudding user response：

Go has three concepts for what C/C programmers think of as a thread: G, P, M.

• M = actual thread
• G = Goroutines (i.e., the code in your program)
• P = Processor

There is no Go API for limiting the number of Ms. There is no API for limiting the number of Gs - a new one gets created every time go func(...) is called. The GOMAXPROCS thing is there to limit Ps.

Each P is used to track the runtime state of some running Goroutine.

You should think of GOMAXPROCS as the peak number of Ms devoted to running Goroutines. (There are other Ms that don't run Goroutines, but handle garbage collection tasks and serve as template threads for creating new Ms as needed etc. Some Ms are devoted to holding runtime state while some Go code is blocked inside a system call.)

So, in terms of the code in your program, GOMAXPROCS is a constraint for how parallel its Go code execution can be. When a running Goroutine reaches a point where it becomes blocked, it is parked and its P is used to resume execution of some other Goroutine that is not blocked.