Is a process the same as a Goroutine in Golang?

Question

For the following code:

func main() {
    goRtns := runtime.NumGoroutine()
    fmt.Println("goroutines:", goRtns)
}

The output is 1. But this is within a "process," with no goroutines being explicitly called:

"In computing, a process is an instance of a computer program that is being executed. It contains the program code and its current activity. Depending on the operating system (OS), a process may be made up of multiple threads of execution that execute instructions concurrently."

Also from the excellent "How goroutines work" blog post by Krishna Sundarram: http://blog.nindalf.com/how-goroutines-work/

"The creation of a goroutine does not require much memory - only 2kB of stack space. They grow by allocating and freeing heap storage as required."

My question is this, then: the instance of code that is running (my simple main.go function) is counted as a goroutine by the runtime library. Am I to assume that the parent process is treated as a go routine, with the same rules of memory allocation, garbage collection, etc? Would it be wise to assume reading a fact about a goroutine's execution is analogous to the overarching go process that runs it? With respect to the second quote on goroutines above, this sounds like a process growing/shrinking its stack space as a program executes which is a standard paradigm in programming.

Do go processes and routines share the same rules? Or am I just missing something about the reported number of goroutines.

Answer 1

Is a process the same as a Goroutine in Golang?

You are using the wrong term process here. In GO everything is a goroutine. as Volker said. and you can see gouroutine definition from here :

A goroutine is a lightweight thread managed by the Go runtime.

for example in your code

func main() {
    goRtns := runtime.NumGoroutine()
    fmt.Println("goroutines:", goRtns)
}

this has only one goroutine because it has only main function and inside there are no go calling here. it just print the something from given variable.

another example if you have go called in your function main :

func main() {

    result := sq(sq(sq(gen(1, 2, 3, 4))))

    numGoroutines := runtime.NumGoroutine()
    fmt.Println("number goroutine = ", numGoroutines)

    fmt.Println(<-result)
    fmt.Println(<-result)
    fmt.Println(<-result)
    fmt.Println(<-result)

}

you can find sq and gen function here. Now the runtime.NumGoroutine() will have 5 gorutine. Since inside function gen and sq we have go called and we combine theme here the total would be 4 + the main the final result is 5.