Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Anonymous goroutines in Golang
In order to be able to understand the anonymous goroutines, we must be aware of the existence of anonymous functions and goroutines. We will first explore the anonymous functions that are the real reason behind the motivation of anonymous goroutines and then we will learn a little about what goroutines are, before finally checking a few examples of anonymous goroutines.
Anonymous functions
In Golang, anonymous functions are those functions that don't have any name. Simply put, anonymous functions don't use any variables as a name when they are declared.
We know that we declare a function with a similar syntax as shown below.
func Sample(){
// some code
}While we do have a name for the above function (Sample), in the case of anonymous functions, we don't have one.
Example 1
A very simple example of an anonymous function is shown below.
package main
import (
"fmt"
)
func main() {
func(name string) {
fmt.Println("Welcome to", name)
}("TutorialsPoint")
}In the above code, we have an anonymous function inside the main function of our Go program. This anonymous function takes one parameter and the argument is passed as soon as the code block of the function ends.
Output
If we run this code, with the command go run main.go, we will see the following output printed in the terminal.
Welcome to TutorialsPoint
goroutines in Golang
A goroutine is an extremely lightweight thread, managed by the Go runtime. Using goroutines, we can write asynchronous parallel programs that can execute some tasks far more quickly than sequential programs would.
Goroutines help us in making the programs asynchronous in nature and let us accomplish more in less time and with fewer resources.
So, the idea behind an anonymous goroutine is that it is simply an anonymous function that runs on a separate goroutine from which it was invoked.
Example 2
Let's take a very basic example of an anonymous goroutine to understand it better.
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("before the anonymous goroutine")
go func(name string) {
fmt.Println("Welcome to", name)
}("TutorialsPoint")
time.Sleep(time.Second)
fmt.Println("after the anonymous goroutine")
}In the above example, we are using an anonymous goroutine and to make sure the main function doesn't finish before the goroutine does its job, we also wrote a time.Sleep() function which will delay the second fmt.Println() by 1 second.
Output
If we run the above code with the help of the go run main.go command, then we will see the following output.
before the anonymous goroutine Welcome to TutorialsPoint after the anonymous goroutine
Instead of writing a time.Sleep() function, we can also use any function that will block the main goroutine which will give enough time to the anonymous goroutine inside the main function to run properly.
Example 3
Consider the code shown below.
package main
import (
"fmt"
)
func main() {
func(name string) {
fmt.Println("Welcome to", name)
}("TutorialsPoint")
fmt.Scanln() // blocking call
}Output
If we run the above code with the help of the go run main.go command, then we will see the following output.
Welcome to TutorialsPoint ...
3K+ Views
To Continue Learning Please Login