Concurrency in Go
Concurrency is the capability to execute multiple tasks simultaneously. Due to the demand for efficient and high-speed processing with multicore processors, 'Go' was developed to facilitate concurrent programming. By leveraging Go subroutines and channels, we can write concurrent programs in Go.
Goroutines
A Goroutine is a thread managed by the Go runtime. When a function is invoked with the 'go' keyword prefix, a new Goroutine will be initiated.
Channels
ch := make(chan string)// Create channel
ch <- stringData // send data to the channel
stringVariable := <-ch // receive data from channel
Buffered Channel
We can specify the buffer length to initialize a buffered
channel.
ch := make(chan string, 2)
In the buffered channel above, we cannot have more than 2 values.
Close channel
The goroutine can close the channel if there are no more values to pass to the process that invoked the goroutine. Similarly, the goroutine invoker can check whether the channel has been closed or not after receiving the final value.
stringVariable, channelStatus := <-ch
Select
The select statement lets a goroutine wait on multiple communication
operations.
Mutex
This assures only one goroutine can access a variable at a
time to avoid conflict and will be used by locking and unlocking the block of
code.
Exercise
Exercise- Continue the exercise from the last part of this learning seriesMastering Go: Part 3 - Programming paradigm(OOP and procedural)
Step 1: Modify the signature of the formatString function to add one more parameter of type chan to receive the channel type variable.
Step 2: Modify the main method and create a new variable of chan type.
Step 3: Call the formatString function for PersonName and Address struct types prefixed with the 'go' keyword.
Update the main method with the following code, and observe the modifications made to the signature of the function formatString and how it is called from the main method:
Step 2: Modify the main method and create a new variable of chan type.
Step 3: Call the formatString function for PersonName and Address struct types prefixed with the 'go' keyword.
Update the main method with the following code, and observe the modifications made to the signature of the function formatString and how it is called from the main method:
package main
import (
"fmt"
dateformater "learngo/date_formater" // import data formater package
stringformater "learngo/string_formater" // import string formater package
)
func main() {
fmt.Println("Crete new date instance using a constructor!")
dateConstructor := dateformater.NewDate("2021", "07", "01")
fmt.Println(dateConstructor.Format())
// Create a channel to communicate and receive data between goroutines
ch := make(chan string)
fmt.Println("Use name format package to format name!")
// Create the instance of PersonName struct
personName := &stringformater.PersonName{FirstName: "Sharad", LastName: "Subedi"}
go formatString(personName, ch)
formatedName := <-ch // receive formatted data from channel
fmt.Println(formatedName)
fmt.Println("Use name format package to format billing address!")
//create the instance of the Address struct
address := &stringformater.Address{StreetNumber: "123", StreetName: "Main St", City: "San Francisco", State: "CA", Zip: "94101"}
go formatString(address, ch)
formatedAddress, channelStatus := <-ch // receive formatted data from channel with channel status
fmt.Println(formatedAddress)
// Check the status of the channel
if channelStatus {
fmt.Println("Channel Ch is not closed! The last value is %s", formatedAddress)
} else {
fmt.Println("Channel Ch is closed! The last value received from channel is %s", formatedAddress)
}
}
// function to format the strings. Takes the interface type as input.
// Example to implement polymorphism using interface
func formatString(formater stringformater.Formater, ch chan string) {
ch <- formater.Format()
}
