Is a process the same as a Goroutine in Golang?

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.

> 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.

You have to be careful about the term process in Go. You quoted a definition about operating system entities called processes that will be recognised very widely. Many people will understand that usage.

But the term is overloaded. The work of C.A.R. Hoare also matters to us: in his Communicating Sequential Processes (CSP) algebra, the term process refers to something small - much more like a super-lightweight thread. His algebra is in a category of mathematics called process algebra.

So it is fair to assume that a goroutine is Go's implementation of a CSP process.

Go is like a much older language, Occam, in this respect. In Occam a process means a CSP process. Occam was widely used for bare-metal (I.e. no operating system) embedded programming and so there was never any ambiguity over the term process.