Go for DevOps/

...

/

Utilizing Goroutines for Concurrency

Utilizing Goroutines for Concurrency

Understand goroutines in Go and how they are used for concurrency and synchronization.

We'll cover the following...

In the modern era of computers, concurrency is the name of the game. In the years before 2005 or so, computers used Moore’s law to double the speed of a single central processing unit (CPU) every 18 months. Multiple CPU consumer systems were rare, and there was one core per CPU in the system. Software that utilized multiple cores efficiently was rare. Over time, it became more expensive to increase single-core speed, and multi-core CPUs have become the norm.

Each core on a CPU supports a number of hardware threads, and operating systems (OSs) provide OS threads that are mapped to hardware threads that are then shared between processes.

Languages can utilize these OS threads to run functions in their language concurrently instead of serially, as we have been doing in all of our code so far.

Starting an OS thread is an expensive operation, and fully utilizing the thread's time requires paying a lot of attention to what we are doing.

Go takes this to another level than most languages with goroutines. Go has built a runtime scheduler that maps these goroutines onto OS threads and switches which routine is running on which thread to optimize CPU utilization.

This produces concurrency that is easy and cheap to use, requiring less mental burden on the developer.

Starting a goroutine

Go gets its name from the go keyword that is used to spawn a goroutine. By applying go before a function call, we can cause that function to execute concurrently with the rest of the code. Here is an example that causes 10 goroutines to be created, with each printing out a number:

Press + to interact
package main
import "fmt"
func main() {
    for i := 0; i < 10; i++ {
        go fmt.Println(i) // This happens concurrently
    }
    fmt.Println("hello")
    // This is used to prevent the program from exiting
    // before our goroutines above run. We will talk about
    // this later.
    select{}
}

Note: We'll also notice that this panics with an error after running. This is because the program will have no running goroutines, which means the program is effectively dead. It is killed by Go's deadlock ...