Goroutines – Concurrency in Golang

20 Nov, 2019
Go language provides a special feature known as a Goroutines. A Goroutine is a function or method which executes independently and simultaneously in connection with any other Goroutines present in your program. Or in other words, every concurrently executing activity in Go language is known as a Goroutines. You can consider a Goroutine like a light weighted thread. The cost of creating Goroutines is very small as compared to the thread. Every program contains at least a single Goroutine and that Goroutine is known as the main Goroutine. All the Goroutines are working under the main Goroutines if the main Goroutine terminated, then all the goroutine present in the program also terminated. Goroutine always works in the background.
You can create your own Goroutine simply by using go keyword as a prefixing to the function or method call as shown in the below syntax:
Syntax:
func name(){
// statements
}

// using go keyword as the 
// prefix of your function call
go name()

Example:
// Go program to illustrate// the concept of Goroutinepackage main  import "fmt"  func display(str string) {    for w := 0; w < 6; w++ {        fmt.Println(str)    }}  func main() {      // Calling Goroutine    go display("Welcome")      // Calling normal function    display("GeeksforGeeks")}
Output:
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks
GeeksforGeeks

In the above example, we simply create a display() function and then call this function in two different ways first one is a Goroutine, i.e. go display(“Welcome”) and another one is a normal function, i.e. display(“GeeksforGeeks”). But there is a problem, it only displays the result of the normal function that does not display the result of Goroutine because when a new Goroutine executed, the Goroutine call return immediately. The control does not wait for Goroutine to complete their execution just like normal function they always move forward to the next line after the Goroutine call and ignores the value returned by the Goroutine. So, to executes a Goroutine properly, we made some changes in our program as shown in the below code:
Modified Example:
// Go program to illustrate the concept of Goroutinepackage main  import (    "fmt"    "time")  func display(str string) {    for w := 0; w < 6; w++ {        time.Sleep(1 * time.Second)        fmt.Println(str)    }}  func main() {      // Calling Goroutine    go display("Welcome")      // Calling normal function    display("GeeksforGeeks")}
Output:
Welcome
GeeksforGeeks
GeeksforGeeks
Welcome
Welcome
GeeksforGeeks
GeeksforGeeks
Welcome
Welcome
GeeksforGeeks
GeeksforGeeks

We added the Sleep() method in our program which makes the main Goroutine sleeps for 1 second in between 1-second the new Goroutine executes, displays “welcome” on the screen, and then terminate after 1-second main Goroutine re-schedule and perform its operation. This process continues until the value of the z<6 after that the main Goroutine terminates. Here, both Goroutine and the normal function work concurrently.
Goroutines are cheaper than threads.
Goroutine are stored in the stack and the size of the stack can grow and shrink according to the requirement of the program. But in threads, the size of the stack is fixed.
Goroutines can communicate using the channel and these channels are specially designed to prevent race conditions when accessing shared memory using Goroutines.
Suppose a program has one thread, and that thread has many Goroutines associated with it. If any of Goroutine blocks the thread due to resource requirement then all the remaining Goroutines will assign to a newly created OS thread. All these details are hidden from the programmers.
In Go language, you can also start Goroutine for an anonymous function or in other words, you can create an anonymous Goroutine simply by using go keyword as a prefix of that function as shown in the below Syntax:
Syntax:
// Anonymous function call
go func (parameter_list){
// statement
}(arguments)

Example:
// Go program to illustrate how// to create an anonymous Goroutinepackage main  import (    "fmt"    "time")  // Main functionfunc main() {      fmt.Println("Welcome!! to Main function")      // Creating Anonymous Goroutine    go func() {          fmt.Println("Welcome!! to GeeksforGeeks")    }()      time.Sleep(1 * time.Second)    fmt.Println("GoodBye!! to Main function")}
Output:
Welcome!! to Main function
Welcome!! to GeeksforGeeks
GoodBye!! to Main function

Golang
Golang-Concurrency
Go Language
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Different ways to concatenate two strings in Golang
time.Sleep() Function in Golang With Examples
strings.Contains Function in Golang with Examples
strings.Replace() Function in Golang With Examples
fmt.Sprintf() Function in Golang With Examples
Golang Maps
Time Formatting in Golang
Interfaces in Golang
Different Ways to Find the Type of Variable in Golang
How to Parse JSON in Golang?