Hey Fellow Gophers,
After a long time, I have decided to jot something down, and this time I have taken up a bit of an ambitious topic. I am going to cover some of the significant features of Go in a series of four blogs “GoRoutines, Channels and Concurrency“. This is a first blog post, where I would like to get you through GoRoutines.
GoRoutines, let’s get into the details.
Do you agree that we have a habit of pursuing multiple things at the same time? Yes, we all do because such things make human beings unique. Such things are very common when we play the radio while doing household chores, singing songs while driving or listening to songs while programming.
GoRoutine allows us to do multiple at a time. It helps the CPU to multitask based on how we specify to it. As per the Golang website `A GoRoutine is a lightweight thread of execution` which enables us to be multithread.
The nature of Golang execution is synchronous, but GoRoutines enables us to run it asynchronously. Or to run a few functions concurrently.
Let’s understand this with a simple example. Assume that we have to wait 30 seconds before printing “Hello” and before printing “World”. First, it will code it using the traditional way that is without GoRoutines then I will do it with GoRoutines. We will monitor the time it takes individually.
Before that let’s have a quick look at the rules of GoRoutines
- To run a function as a GoRoutine, we have to precede the function call with the keyword `Go`
E.g. If we need to call the function RunAsynchronously() as a GoRoutine we will call it as `go RunAsynchronously()` - As soon as the synchronous function execution stops, the GoRoutine execution stops as well regardless of the completion of the function – I have mentioned in on a later stage.
First of all, let’s create a function that will calculate the time execution for the code programmed in it.
package main
import (
"fmt"
"time"
)
func simple(funcToExec func()) {
start := time.Now()
funcToExec()
elapsed := time.Since(start)
fmt.Println("Time Taken for function to execute: ", elapsed)
}
func main() {
}
So traditionally the code would look something like this.
package main
import (
"fmt"
"time"
)
func simple(funcToExec func()) {
start := time.Now()
funcToExec()
elapsed := time.Since(start)Ç
fmt.Println("Time Taken for function to execute: ", elapsed)
}
func main() {
fmt.Println("Traditional Execution")
simple(PrintHelloWorldTraditionally)
}
func PrintWith30SecDelay(text string) {
time.Sleep(30 * time.Second)
fmt.Println(text)
}
func PrintHelloWorldTraditionally() {
PrintWith30SecDelay("Hello")
PrintWith30SecDelay("World")
}
Output:
Traditional Execution Hello World Time Taken for function to execute: 1m0s
Now let’s see the difference if we run one of the print as a GoRoutine
package main
import (
"fmt"
"time"
)
func simple(funcToExec func()) {
start := time.Now()
funcToExec()
elapsed := time.Since(start)
fmt.Println("Time Taken for function to execute: ", elapsed)
}
func main() {
fmt.Println("Traditional Execution")
simple(PrintHelloWorldTraditionally)
fmt.Println("Execution with GoRoutines")
simple(PrintHelloWorldWithGoRoutines)
}
func PrintWith30SecDelay(text string) {
time.Sleep(30 * time.Second)
fmt.Println(text)
}
func PrintHelloWorldTraditionally() {
PrintWith30SecDelay("Hello")
PrintWith30SecDelay("World")
}
func PrintHelloWorldWithGoRoutines() {
go PrintWith30SecDelay("Hello")
PrintWith30SecDelay("World")
}
Output:
Traditional Execution Hello World Time Taken for the function to execute: 1m0s Execution with GoRoutines Hello World Time Taken for the function to execute: 30s
So the call of the function that prints “Hello” and of the function that prints “World” happens concurrently. Thus the delay is reduced.
But if you switch the GoRoutine declaration to be
PrintWith30SecDelay("Hello")
go PrintWith30SecDelay("World")
instead of
go PrintWith30SecDelay("Hello")
PrintWith30SecDelay("World")
It will result in not printing of the word “World”. But why so?
It is because the execution of `PrintWith30SecDelay(“Hello”)` happens a microsecond earlier to that of `PrintWith30SecDelay(“World”)`. Resulting into completion of `PrintWith30SecDelay(“Hello”)` to be a microsecond earlier.
So how can we solve this specific problem? The answer is with the help of WaitGroups.
Let’s look at the code on how we would do it?
package main
import (
"fmt"
"sync"
"time"
)
var wg sync.WaitGroup
func simple(funcToExec func()) {
start := time.Now()
funcToExec()
elapsed := time.Since(start)
fmt.Println("Time Taken for function to execute: ", elapsed)
}
func main() {
fmt.Println("Traditional Execution")
simple(PrintHelloWorldTraditionally)
fmt.Println("Execution with GoRoutines")
simple(PrintHelloWorldWithGoRoutines)
}
func PrintWith30SecDelay(text string, wgAdded bool) {
if wgAdded {
defer wg.Done()
}
time.Sleep(30 * time.Second)
fmt.Println(text)
}
func PrintHelloWorldTraditionally() {
PrintWith30SecDelay("Hello", false)
PrintWith30SecDelay("World", false)
}
func PrintHelloWorldWithGoRoutines() {
wg.Add(1)
go PrintWith30SecDelay("Hello", true)
wg.Add(1)
go PrintWith30SecDelay("World", true)
wg.Wait()
}
Output:
Traditional Execution Hello World Time Taken for the function to execute: 8s Execution with GoRoutines Hello World Time Taken for the function to execute: 4s
Note: GoRoutines and WaitGroups are to be used carefully, or it is likely for it to end up not working correctly or being stuck in a Deadlock.
This is something that we can achieve with channels as well that I am going to cover it in the next blog.
In case, if you are looking for the Golang experts to build a world-class enterprise app with high speed, high security, and high modularity, then hire golang developer from us. Our Golang programmers have in-depth knowledge and extensive experience in converting potential ideas into a viable business solution.
Regarding this blog, do let me know your thoughts in the comments section below. I will soon be back with the next part `GoRoutines, Channels and Concurrency in a Nutshell: Part 2 (Channels)` coming soon.
Ciao.
Happy Coding Gophers!